1 /** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 */ 19 package org.apache.hadoop.hbase.client; 20 21 import java.io.Closeable; 22 import java.io.IOException; 23 import java.util.List; 24 import java.util.Map; 25 import java.util.concurrent.Future; 26 import java.util.regex.Pattern; 27 28 import org.apache.hadoop.conf.Configuration; 29 import org.apache.hadoop.hbase.Abortable; 30 import org.apache.hadoop.hbase.ClusterStatus; 31 import org.apache.hadoop.hbase.HColumnDescriptor; 32 import org.apache.hadoop.hbase.HRegionInfo; 33 import org.apache.hadoop.hbase.HTableDescriptor; 34 import org.apache.hadoop.hbase.NamespaceDescriptor; 35 import org.apache.hadoop.hbase.ProcedureInfo; 36 import org.apache.hadoop.hbase.ServerName; 37 import org.apache.hadoop.hbase.TableExistsException; 38 import org.apache.hadoop.hbase.TableName; 39 import org.apache.hadoop.hbase.TableNotFoundException; 40 import org.apache.hadoop.hbase.backup.BackupRequest; 41 import org.apache.hadoop.hbase.backup.BackupType; 42 import org.apache.hadoop.hbase.classification.InterfaceAudience; 43 import org.apache.hadoop.hbase.classification.InterfaceStability; 44 import org.apache.hadoop.hbase.ipc.CoprocessorRpcChannel; 45 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos; 46 import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos; 47 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos; 48 import org.apache.hadoop.hbase.quotas.QuotaFilter; 49 import org.apache.hadoop.hbase.quotas.QuotaRetriever; 50 import org.apache.hadoop.hbase.quotas.QuotaSettings; 51 import org.apache.hadoop.hbase.regionserver.wal.FailedLogCloseException; 52 import org.apache.hadoop.hbase.snapshot.HBaseSnapshotException; 53 import org.apache.hadoop.hbase.snapshot.RestoreSnapshotException; 54 import org.apache.hadoop.hbase.snapshot.SnapshotCreationException; 55 import org.apache.hadoop.hbase.snapshot.UnknownSnapshotException; 56 import org.apache.hadoop.hbase.util.Pair; 57 58 /** 59 * The administrative API for HBase. Obtain an instance from an {@link Connection#getAdmin()} and 60 * call {@link #close()} afterwards. 61 * <p>Admin can be used to create, drop, list, enable and disable tables, add and drop table 62 * column families and other administrative operations. 63 * 64 * @see ConnectionFactory 65 * @see Connection 66 * @see Table 67 * @since 0.99.0 68 */ 69 @InterfaceAudience.Public 70 @InterfaceStability.Evolving 71 public interface Admin extends Abortable, Closeable { 72 int getOperationTimeout(); 73 74 @Override 75 void abort(String why, Throwable e); 76 77 @Override 78 boolean isAborted(); 79 80 /** 81 * @return Connection used by this object. 82 */ 83 Connection getConnection(); 84 85 /** 86 * @param tableName Table to check. 87 * @return True if table exists already. 88 * @throws IOException 89 */ 90 boolean tableExists(final TableName tableName) throws IOException; 91 92 /** 93 * List all the userspace tables. 94 * 95 * @return - returns an array of HTableDescriptors 96 * @throws IOException if a remote or network exception occurs 97 */ 98 HTableDescriptor[] listTables() throws IOException; 99 100 /** 101 * List all the userspace tables matching the given pattern. 102 * 103 * @param pattern The compiled regular expression to match against 104 * @return - returns an array of HTableDescriptors 105 * @throws IOException if a remote or network exception occurs 106 * @see #listTables() 107 */ 108 HTableDescriptor[] listTables(Pattern pattern) throws IOException; 109 110 /** 111 * List all the userspace tables matching the given regular expression. 112 * 113 * @param regex The regular expression to match against 114 * @return - returns an array of HTableDescriptors 115 * @throws IOException if a remote or network exception occurs 116 * @see #listTables(java.util.regex.Pattern) 117 */ 118 HTableDescriptor[] listTables(String regex) throws IOException; 119 120 /** 121 * List all the tables matching the given pattern. 122 * 123 * @param pattern The compiled regular expression to match against 124 * @param includeSysTables False to match only against userspace tables 125 * @return - returns an array of HTableDescriptors 126 * @throws IOException if a remote or network exception occurs 127 * @see #listTables() 128 */ 129 HTableDescriptor[] listTables(Pattern pattern, boolean includeSysTables) 130 throws IOException; 131 132 /** 133 * List all the tables matching the given pattern. 134 * 135 * @param regex The regular expression to match against 136 * @param includeSysTables False to match only against userspace tables 137 * @return - returns an array of HTableDescriptors 138 * @throws IOException if a remote or network exception occurs 139 * @see #listTables(java.util.regex.Pattern, boolean) 140 */ 141 HTableDescriptor[] listTables(String regex, boolean includeSysTables) 142 throws IOException; 143 144 /** 145 * List all of the names of userspace tables. 146 * 147 * @return TableName[] table names 148 * @throws IOException if a remote or network exception occurs 149 */ 150 TableName[] listTableNames() throws IOException; 151 152 /** 153 * List all of the names of userspace tables. 154 * @param pattern The regular expression to match against 155 * @return TableName[] table names 156 * @throws IOException if a remote or network exception occurs 157 */ 158 TableName[] listTableNames(Pattern pattern) throws IOException; 159 160 /** 161 * List all of the names of userspace tables. 162 * @param regex The regular expression to match against 163 * @return TableName[] table names 164 * @throws IOException if a remote or network exception occurs 165 */ 166 TableName[] listTableNames(String regex) throws IOException; 167 168 /** 169 * List all of the names of userspace tables. 170 * @param pattern The regular expression to match against 171 * @param includeSysTables False to match only against userspace tables 172 * @return TableName[] table names 173 * @throws IOException if a remote or network exception occurs 174 */ 175 TableName[] listTableNames(final Pattern pattern, final boolean includeSysTables) 176 throws IOException; 177 178 /** 179 * List all of the names of userspace tables. 180 * @param regex The regular expression to match against 181 * @param includeSysTables False to match only against userspace tables 182 * @return TableName[] table names 183 * @throws IOException if a remote or network exception occurs 184 */ 185 TableName[] listTableNames(final String regex, final boolean includeSysTables) 186 throws IOException; 187 188 /** 189 * Method for getting the tableDescriptor 190 * 191 * @param tableName as a {@link TableName} 192 * @return the tableDescriptor 193 * @throws org.apache.hadoop.hbase.TableNotFoundException 194 * @throws IOException if a remote or network exception occurs 195 */ 196 HTableDescriptor getTableDescriptor(final TableName tableName) 197 throws TableNotFoundException, IOException; 198 199 /** 200 * Creates a new table. Synchronous operation. 201 * 202 * @param desc table descriptor for table 203 * @throws IllegalArgumentException if the table name is reserved 204 * @throws MasterNotRunningException if master is not running 205 * @throws org.apache.hadoop.hbase.TableExistsException if table already exists (If concurrent 206 * threads, the table may have been created between test-for-existence and attempt-at-creation). 207 * @throws IOException if a remote or network exception occurs 208 */ 209 void createTable(HTableDescriptor desc) throws IOException; 210 211 /** 212 * Creates a new table with the specified number of regions. The start key specified will become 213 * the end key of the first region of the table, and the end key specified will become the start 214 * key of the last region of the table (the first region has a null start key and the last region 215 * has a null end key). BigInteger math will be used to divide the key range specified into enough 216 * segments to make the required number of total regions. Synchronous operation. 217 * 218 * @param desc table descriptor for table 219 * @param startKey beginning of key range 220 * @param endKey end of key range 221 * @param numRegions the total number of regions to create 222 * @throws IllegalArgumentException if the table name is reserved 223 * @throws MasterNotRunningException if master is not running 224 * @throws org.apache.hadoop.hbase.TableExistsException if table already exists (If concurrent 225 * threads, the table may have been created between test-for-existence and attempt-at-creation). 226 * @throws IOException 227 */ 228 void createTable(HTableDescriptor desc, byte[] startKey, byte[] endKey, int numRegions) 229 throws IOException; 230 231 /** 232 * Creates a new table with an initial set of empty regions defined by the specified split keys. 233 * The total number of regions created will be the number of split keys plus one. Synchronous 234 * operation. Note : Avoid passing empty split key. 235 * 236 * @param desc table descriptor for table 237 * @param splitKeys array of split keys for the initial regions of the table 238 * @throws IllegalArgumentException if the table name is reserved, if the split keys are repeated 239 * and if the split key has empty byte array. 240 * @throws MasterNotRunningException if master is not running 241 * @throws org.apache.hadoop.hbase.TableExistsException if table already exists (If concurrent 242 * threads, the table may have been created between test-for-existence and attempt-at-creation). 243 * @throws IOException 244 */ 245 void createTable(final HTableDescriptor desc, byte[][] splitKeys) throws IOException; 246 247 /** 248 * Creates a new table but does not block and wait for it to come online. Asynchronous operation. 249 * To check if the table exists, use {@link #isTableAvailable} -- it is not safe to create an 250 * HTable instance to this table before it is available. Note : Avoid passing empty split key. 251 * 252 * @param desc table descriptor for table 253 * @throws IllegalArgumentException Bad table name, if the split keys are repeated and if the 254 * split key has empty byte array. 255 * @throws MasterNotRunningException if master is not running 256 * @throws org.apache.hadoop.hbase.TableExistsException if table already exists (If concurrent 257 * threads, the table may have been created between test-for-existence and attempt-at-creation). 258 * @throws IOException 259 */ 260 void createTableAsync(final HTableDescriptor desc, final byte[][] splitKeys) throws IOException; 261 262 /** 263 * Deletes a table. Synchronous operation. 264 * 265 * @param tableName name of table to delete 266 * @throws IOException if a remote or network exception occurs 267 */ 268 void deleteTable(final TableName tableName) throws IOException; 269 270 /** 271 * Deletes tables matching the passed in pattern and wait on completion. Warning: Use this method 272 * carefully, there is no prompting and the effect is immediate. Consider using {@link 273 * #listTables(java.lang.String)} and {@link #deleteTable(org.apache.hadoop.hbase.TableName)} 274 * 275 * @param regex The regular expression to match table names against 276 * @return Table descriptors for tables that couldn't be deleted 277 * @throws IOException 278 * @see #deleteTables(java.util.regex.Pattern) 279 * @see #deleteTable(org.apache.hadoop.hbase.TableName) 280 */ 281 HTableDescriptor[] deleteTables(String regex) throws IOException; 282 283 /** 284 * Delete tables matching the passed in pattern and wait on completion. Warning: Use this method 285 * carefully, there is no prompting and the effect is immediate. Consider using {@link 286 * #listTables(java.util.regex.Pattern) } and 287 * {@link #deleteTable(org.apache.hadoop.hbase.TableName)} 288 * 289 * @param pattern The pattern to match table names against 290 * @return Table descriptors for tables that couldn't be deleted 291 * @throws IOException 292 */ 293 HTableDescriptor[] deleteTables(Pattern pattern) throws IOException; 294 295 /** 296 * Truncate a table. 297 * Synchronous operation. 298 * 299 * @param tableName name of table to truncate 300 * @param preserveSplits True if the splits should be preserved 301 * @throws IOException if a remote or network exception occurs 302 */ 303 public void truncateTable(final TableName tableName, final boolean preserveSplits) 304 throws IOException; 305 306 /** 307 * Enable a table. May timeout. Use {@link #enableTableAsync(org.apache.hadoop.hbase.TableName)} 308 * and {@link #isTableEnabled(org.apache.hadoop.hbase.TableName)} instead. The table has to be in 309 * disabled state for it to be enabled. 310 * 311 * @param tableName name of the table 312 * @throws IOException if a remote or network exception occurs There could be couple types of 313 * IOException TableNotFoundException means the table doesn't exist. TableNotDisabledException 314 * means the table isn't in disabled state. 315 * @see #isTableEnabled(org.apache.hadoop.hbase.TableName) 316 * @see #disableTable(org.apache.hadoop.hbase.TableName) 317 * @see #enableTableAsync(org.apache.hadoop.hbase.TableName) 318 */ 319 void enableTable(final TableName tableName) throws IOException; 320 321 /** 322 * Brings a table on-line (enables it). Method returns immediately though enable of table may 323 * take some time to complete, especially if the table is large (All regions are opened as part of 324 * enabling process). Check {@link #isTableEnabled(org.apache.hadoop.hbase.TableName)} to learn 325 * when table is fully online. If table is taking too long to online, check server logs. 326 * 327 * @param tableName 328 * @throws IOException 329 * @since 0.90.0 330 */ 331 void enableTableAsync(final TableName tableName) throws IOException; 332 333 /** 334 * Enable tables matching the passed in pattern and wait on completion. Warning: Use this method 335 * carefully, there is no prompting and the effect is immediate. Consider using {@link 336 * #listTables(java.lang.String)} and {@link #enableTable(org.apache.hadoop.hbase.TableName)} 337 * 338 * @param regex The regular expression to match table names against 339 * @throws IOException 340 * @see #enableTables(java.util.regex.Pattern) 341 * @see #enableTable(org.apache.hadoop.hbase.TableName) 342 */ 343 HTableDescriptor[] enableTables(String regex) throws IOException; 344 345 /** 346 * Enable tables matching the passed in pattern and wait on completion. Warning: Use this method 347 * carefully, there is no prompting and the effect is immediate. Consider using {@link 348 * #listTables(java.util.regex.Pattern) } and 349 * {@link #enableTable(org.apache.hadoop.hbase.TableName)} 350 * 351 * @param pattern The pattern to match table names against 352 * @throws IOException 353 */ 354 HTableDescriptor[] enableTables(Pattern pattern) throws IOException; 355 356 /** 357 * Starts the disable of a table. If it is being served, the master will tell the servers to stop 358 * serving it. This method returns immediately. The disable of a table can take some time if the 359 * table is large (all regions are closed as part of table disable operation). Call {@link 360 * #isTableDisabled(org.apache.hadoop.hbase.TableName)} to check for when disable completes. If 361 * table is taking too long to online, check server logs. 362 * 363 * @param tableName name of table 364 * @throws IOException if a remote or network exception occurs 365 * @see #isTableDisabled(org.apache.hadoop.hbase.TableName) 366 * @see #isTableEnabled(org.apache.hadoop.hbase.TableName) 367 * @since 0.90.0 368 */ 369 void disableTableAsync(final TableName tableName) throws IOException; 370 371 /** 372 * Disable table and wait on completion. May timeout eventually. Use {@link 373 * #disableTableAsync(org.apache.hadoop.hbase.TableName)} and 374 * {@link #isTableDisabled(org.apache.hadoop.hbase.TableName)} instead. The table has to be in 375 * enabled state for it to be disabled. 376 * 377 * @param tableName 378 * @throws IOException There could be couple types of IOException TableNotFoundException means the 379 * table doesn't exist. TableNotEnabledException means the table isn't in enabled state. 380 */ 381 void disableTable(final TableName tableName) throws IOException; 382 383 /** 384 * Disable tables matching the passed in pattern and wait on completion. Warning: Use this method 385 * carefully, there is no prompting and the effect is immediate. Consider using {@link 386 * #listTables(java.lang.String)} and {@link #disableTable(org.apache.hadoop.hbase.TableName)} 387 * 388 * @param regex The regular expression to match table names against 389 * @return Table descriptors for tables that couldn't be disabled 390 * @throws IOException 391 * @see #disableTables(java.util.regex.Pattern) 392 * @see #disableTable(org.apache.hadoop.hbase.TableName) 393 */ 394 HTableDescriptor[] disableTables(String regex) throws IOException; 395 396 /** 397 * Disable tables matching the passed in pattern and wait on completion. Warning: Use this method 398 * carefully, there is no prompting and the effect is immediate. Consider using {@link 399 * #listTables(java.util.regex.Pattern) } and 400 * {@link #disableTable(org.apache.hadoop.hbase.TableName)} 401 * 402 * @param pattern The pattern to match table names against 403 * @return Table descriptors for tables that couldn't be disabled 404 * @throws IOException 405 */ 406 HTableDescriptor[] disableTables(Pattern pattern) throws IOException; 407 408 /** 409 * @param tableName name of table to check 410 * @return true if table is on-line 411 * @throws IOException if a remote or network exception occurs 412 */ 413 boolean isTableEnabled(TableName tableName) throws IOException; 414 415 /** 416 * @param tableName name of table to check 417 * @return true if table is off-line 418 * @throws IOException if a remote or network exception occurs 419 */ 420 boolean isTableDisabled(TableName tableName) throws IOException; 421 422 /** 423 * @param tableName name of table to check 424 * @return true if all regions of the table are available 425 * @throws IOException if a remote or network exception occurs 426 */ 427 boolean isTableAvailable(TableName tableName) throws IOException; 428 429 /** 430 * Use this api to check if the table has been created with the specified number of splitkeys 431 * which was used while creating the given table. Note : If this api is used after a table's 432 * region gets splitted, the api may return false. 433 * 434 * @param tableName name of table to check 435 * @param splitKeys keys to check if the table has been created with all split keys 436 * @throws IOException if a remote or network excpetion occurs 437 */ 438 boolean isTableAvailable(TableName tableName, byte[][] splitKeys) throws IOException; 439 440 /** 441 * Get the status of alter command - indicates how many regions have received the updated schema 442 * Asynchronous operation. 443 * 444 * @param tableName TableName instance 445 * @return Pair indicating the number of regions updated Pair.getFirst() is the regions that are 446 * yet to be updated Pair.getSecond() is the total number of regions of the table 447 * @throws IOException if a remote or network exception occurs 448 */ 449 Pair<Integer, Integer> getAlterStatus(final TableName tableName) throws IOException; 450 451 /** 452 * Get the status of alter command - indicates how many regions have received the updated schema 453 * Asynchronous operation. 454 * 455 * @param tableName name of the table to get the status of 456 * @return Pair indicating the number of regions updated Pair.getFirst() is the regions that are 457 * yet to be updated Pair.getSecond() is the total number of regions of the table 458 * @throws IOException if a remote or network exception occurs 459 */ 460 Pair<Integer, Integer> getAlterStatus(final byte[] tableName) throws IOException; 461 462 /** 463 * Add a column to an existing table. Asynchronous operation. 464 * 465 * @param tableName name of the table to add column to 466 * @param column column descriptor of column to be added 467 * @throws IOException if a remote or network exception occurs 468 */ 469 void addColumn(final TableName tableName, final HColumnDescriptor column) throws IOException; 470 471 /** 472 * Delete a column from a table. Asynchronous operation. 473 * 474 * @param tableName name of table 475 * @param columnName name of column to be deleted 476 * @throws IOException if a remote or network exception occurs 477 */ 478 void deleteColumn(final TableName tableName, final byte[] columnName) throws IOException; 479 480 /** 481 * Modify an existing column family on a table. Asynchronous operation. 482 * 483 * @param tableName name of table 484 * @param descriptor new column descriptor to use 485 * @throws IOException if a remote or network exception occurs 486 */ 487 void modifyColumn(final TableName tableName, final HColumnDescriptor descriptor) 488 throws IOException; 489 490 /** 491 * Close a region. For expert-admins. Runs close on the regionserver. The master will not be 492 * informed of the close. 493 * 494 * @param regionname region name to close 495 * @param serverName If supplied, we'll use this location rather than the one currently in 496 * <code>hbase:meta</code> 497 * @throws IOException if a remote or network exception occurs 498 */ 499 void closeRegion(final String regionname, final String serverName) throws IOException; 500 501 /** 502 * Close a region. For expert-admins Runs close on the regionserver. The master will not be 503 * informed of the close. 504 * 505 * @param regionname region name to close 506 * @param serverName The servername of the regionserver. If passed null we will use servername 507 * found in the hbase:meta table. A server name is made of host, port and startcode. Here is an 508 * example: <code> host187.example.com,60020,1289493121758</code> 509 * @throws IOException if a remote or network exception occurs 510 */ 511 void closeRegion(final byte[] regionname, final String serverName) throws IOException; 512 513 /** 514 * For expert-admins. Runs close on the regionserver. Closes a region based on the encoded region 515 * name. The region server name is mandatory. If the servername is provided then based on the 516 * online regions in the specified regionserver the specified region will be closed. The master 517 * will not be informed of the close. Note that the regionname is the encoded regionname. 518 * 519 * @param encodedRegionName The encoded region name; i.e. the hash that makes up the region name 520 * suffix: e.g. if regionname is 521 * <code>TestTable,0094429456,1289497600452.527db22f95c8a9e0116f0cc13c680396.</code>, 522 * then the encoded region name is: <code>527db22f95c8a9e0116f0cc13c680396</code>. 523 * @param serverName The servername of the regionserver. A server name is made of host, port and 524 * startcode. This is mandatory. Here is an example: 525 * <code> host187.example.com,60020,1289493121758</code> 526 * @return true if the region was closed, false if not. 527 * @throws IOException if a remote or network exception occurs 528 */ 529 boolean closeRegionWithEncodedRegionName(final String encodedRegionName, final String serverName) 530 throws IOException; 531 532 /** 533 * Close a region. For expert-admins Runs close on the regionserver. The master will not be 534 * informed of the close. 535 * 536 * @param sn 537 * @param hri 538 * @throws IOException 539 */ 540 void closeRegion(final ServerName sn, final HRegionInfo hri) throws IOException; 541 542 /** 543 * Get all the online regions on a region server. 544 */ 545 List<HRegionInfo> getOnlineRegions(final ServerName sn) throws IOException; 546 547 /** 548 * Flush a table. Synchronous operation. 549 * 550 * @param tableName table to flush 551 * @throws IOException if a remote or network exception occurs 552 */ 553 void flush(final TableName tableName) throws IOException; 554 555 /** 556 * Flush an individual region. Synchronous operation. 557 * 558 * @param regionName region to flush 559 * @throws IOException if a remote or network exception occurs 560 */ 561 void flushRegion(final byte[] regionName) throws IOException; 562 563 /** 564 * Compact a table. Asynchronous operation. 565 * 566 * @param tableName table to compact 567 * @throws IOException if a remote or network exception occurs 568 */ 569 void compact(final TableName tableName) throws IOException; 570 571 /** 572 * Compact an individual region. Asynchronous operation. 573 * 574 * @param regionName region to compact 575 * @throws IOException if a remote or network exception occurs 576 */ 577 void compactRegion(final byte[] regionName) throws IOException; 578 579 /** 580 * Compact a column family within a table. Asynchronous operation. 581 * 582 * @param tableName table to compact 583 * @param columnFamily column family within a table 584 * @throws IOException if a remote or network exception occurs 585 */ 586 void compact(final TableName tableName, final byte[] columnFamily) 587 throws IOException; 588 589 /** 590 * Compact a column family within a region. Asynchronous operation. 591 * 592 * @param regionName region to compact 593 * @param columnFamily column family within a region 594 * @throws IOException if a remote or network exception occurs 595 */ 596 void compactRegion(final byte[] regionName, final byte[] columnFamily) 597 throws IOException; 598 599 /** 600 * Major compact a table. Asynchronous operation. 601 * 602 * @param tableName table to major compact 603 * @throws IOException if a remote or network exception occurs 604 */ 605 void majorCompact(TableName tableName) throws IOException; 606 607 /** 608 * Major compact a table or an individual region. Asynchronous operation. 609 * 610 * @param regionName region to major compact 611 * @throws IOException if a remote or network exception occurs 612 */ 613 void majorCompactRegion(final byte[] regionName) throws IOException; 614 615 /** 616 * Major compact a column family within a table. Asynchronous operation. 617 * 618 * @param tableName table to major compact 619 * @param columnFamily column family within a table 620 * @throws IOException if a remote or network exception occurs 621 */ 622 void majorCompact(TableName tableName, final byte[] columnFamily) 623 throws IOException; 624 625 /** 626 * Major compact a column family within region. Asynchronous operation. 627 * 628 * @param regionName egion to major compact 629 * @param columnFamily column family within a region 630 * @throws IOException if a remote or network exception occurs 631 */ 632 void majorCompactRegion(final byte[] regionName, final byte[] columnFamily) 633 throws IOException; 634 635 /** 636 * Compact all regions on the region server 637 * @param sn the region server name 638 * @param major if it's major compaction 639 * @throws IOException 640 * @throws InterruptedException 641 */ 642 public void compactRegionServer(final ServerName sn, boolean major) 643 throws IOException, InterruptedException; 644 645 /** 646 * Move the region <code>r</code> to <code>dest</code>. 647 * 648 * @param encodedRegionName The encoded region name; i.e. the hash that makes up the region name 649 * suffix: e.g. if regionname is 650 * <code>TestTable,0094429456,1289497600452.527db22f95c8a9e0116f0cc13c680396.</code>, 651 * then the encoded region name is: <code>527db22f95c8a9e0116f0cc13c680396</code>. 652 * @param destServerName The servername of the destination regionserver. If passed the empty byte 653 * array we'll assign to a random server. A server name is made of host, port and startcode. 654 * Here is an example: <code> host187.example.com,60020,1289493121758</code> 655 * @throws UnknownRegionException Thrown if we can't find a region named 656 * <code>encodedRegionName</code> 657 */ 658 void move(final byte[] encodedRegionName, final byte[] destServerName) 659 throws IOException; 660 661 /** 662 * @param regionName Region name to assign. 663 */ 664 void assign(final byte[] regionName) 665 throws IOException; 666 667 /** 668 * Unassign a region from current hosting regionserver. Region will then be assigned to a 669 * regionserver chosen at random. Region could be reassigned back to the same server. Use {@link 670 * #move(byte[], byte[])} if you want to control the region movement. 671 * 672 * @param regionName Region to unassign. Will clear any existing RegionPlan if one found. 673 * @param force If true, force unassign (Will remove region from regions-in-transition too if 674 * present. If results in double assignment use hbck -fix to resolve. To be used by experts). 675 */ 676 void unassign(final byte[] regionName, final boolean force) 677 throws IOException; 678 679 /** 680 * Offline specified region from master's in-memory state. It will not attempt to reassign the 681 * region as in unassign. This API can be used when a region not served by any region server and 682 * still online as per Master's in memory state. If this API is incorrectly used on active region 683 * then master will loose track of that region. This is a special method that should be used by 684 * experts or hbck. 685 * 686 * @param regionName Region to offline. 687 * @throws IOException 688 */ 689 void offline(final byte[] regionName) throws IOException; 690 691 /** 692 * Turn the load balancer on or off. 693 * 694 * @param synchronous If true, it waits until current balance() call, if outstanding, to return. 695 * @return Previous balancer value 696 */ 697 boolean setBalancerRunning(final boolean on, final boolean synchronous) 698 throws IOException; 699 700 /** 701 * Invoke the balancer. Will run the balancer and if regions to move, it will go ahead and do the 702 * reassignments. Can NOT run for various reasons. Check logs. 703 * 704 * @return True if balancer ran, false otherwise. 705 */ 706 boolean balancer() throws IOException; 707 708 /** 709 * Invoke the balancer. Will run the balancer and if regions to move, it will 710 * go ahead and do the reassignments. If there is region in transition, force parameter of true 711 * would still run balancer. Can *not* run for other reasons. Check 712 * logs. 713 * @param force whether we should force balance even if there is region in transition 714 * @return True if balancer ran, false otherwise. 715 */ 716 boolean balancer(boolean force) throws IOException; 717 718 /** 719 * Query the current state of the balancer 720 * 721 * @return true if the balancer is enabled, false otherwise. 722 */ 723 boolean isBalancerEnabled() throws IOException; 724 725 /** 726 * Invoke region normalizer. Can NOT run for various reasons. Check logs. 727 * 728 * @return True if region normalizer ran, false otherwise. 729 */ 730 boolean normalize() throws IOException; 731 732 /** 733 * Query the current state of the region normalizer 734 * 735 * @return true if region normalizer is enabled, false otherwise. 736 */ 737 boolean isNormalizerEnabled() throws IOException; 738 739 /** 740 * Turn region normalizer on or off. 741 * 742 * @return Previous normalizer value 743 */ 744 boolean setNormalizerRunning(final boolean on) 745 throws IOException; 746 747 /** 748 * Enable/Disable the catalog janitor 749 * 750 * @param enable if true enables the catalog janitor 751 * @return the previous state 752 */ 753 boolean enableCatalogJanitor(boolean enable) throws IOException; 754 755 /** 756 * Ask for a scan of the catalog table 757 * 758 * @return the number of entries cleaned 759 */ 760 int runCatalogScan() throws IOException; 761 762 /** 763 * Query on the catalog janitor state (Enabled/Disabled?) 764 * 765 */ 766 boolean isCatalogJanitorEnabled() throws IOException; 767 768 /** 769 * Merge two regions. Asynchronous operation. 770 * 771 * @param encodedNameOfRegionA encoded name of region a 772 * @param encodedNameOfRegionB encoded name of region b 773 * @param forcible true if do a compulsory merge, otherwise we will only merge two adjacent 774 * regions 775 * @throws IOException 776 */ 777 void mergeRegions(final byte[] encodedNameOfRegionA, final byte[] encodedNameOfRegionB, 778 final boolean forcible) throws IOException; 779 780 /** 781 * Split a table. Asynchronous operation. 782 * 783 * @param tableName table to split 784 * @throws IOException if a remote or network exception occurs 785 */ 786 void split(final TableName tableName) throws IOException; 787 788 /** 789 * Split an individual region. Asynchronous operation. 790 * 791 * @param regionName region to split 792 * @throws IOException if a remote or network exception occurs 793 */ 794 void splitRegion(final byte[] regionName) throws IOException; 795 796 /** 797 * Split a table. Asynchronous operation. 798 * 799 * @param tableName table to split 800 * @param splitPoint the explicit position to split on 801 * @throws IOException if a remote or network exception occurs 802 */ 803 void split(final TableName tableName, final byte[] splitPoint) 804 throws IOException; 805 806 /** 807 * Split an individual region. Asynchronous operation. 808 * 809 * @param regionName region to split 810 * @param splitPoint the explicit position to split on 811 * @throws IOException if a remote or network exception occurs 812 */ 813 void splitRegion(final byte[] regionName, final byte[] splitPoint) 814 throws IOException; 815 816 817 /** 818 * Modify an existing table, more IRB friendly version. Asynchronous operation. This means that 819 * it may be a while before your schema change is updated across all of the table. 820 * 821 * @param tableName name of table. 822 * @param htd modified description of the table 823 * @throws IOException if a remote or network exception occurs 824 */ 825 void modifyTable(final TableName tableName, final HTableDescriptor htd) 826 throws IOException; 827 828 /** 829 * Shuts down the HBase cluster 830 * 831 * @throws IOException if a remote or network exception occurs 832 */ 833 void shutdown() throws IOException; 834 835 /** 836 * Shuts down the current HBase master only. Does not shutdown the cluster. 837 * 838 * @throws IOException if a remote or network exception occurs 839 * @see #shutdown() 840 */ 841 void stopMaster() throws IOException; 842 843 /** 844 * Check whether Master is in maintenance mode 845 * 846 * @throws IOException if a remote or network exception occurs 847 */ 848 boolean isMasterInMaintenanceMode() throws IOException; 849 850 /** 851 * Stop the designated regionserver 852 * 853 * @param hostnamePort Hostname and port delimited by a <code>:</code> as in 854 * <code>example.org:1234</code> 855 * @throws IOException if a remote or network exception occurs 856 */ 857 void stopRegionServer(final String hostnamePort) throws IOException; 858 859 /** 860 * @return cluster status 861 * @throws IOException if a remote or network exception occurs 862 */ 863 ClusterStatus getClusterStatus() throws IOException; 864 865 /** 866 * @return Configuration used by the instance. 867 */ 868 Configuration getConfiguration(); 869 870 /** 871 * Create a new namespace 872 * 873 * @param descriptor descriptor which describes the new namespace 874 * @throws IOException 875 */ 876 void createNamespace(final NamespaceDescriptor descriptor) 877 throws IOException; 878 879 /** 880 * Modify an existing namespace 881 * 882 * @param descriptor descriptor which describes the new namespace 883 * @throws IOException 884 */ 885 void modifyNamespace(final NamespaceDescriptor descriptor) 886 throws IOException; 887 888 /** 889 * Delete an existing namespace. Only empty namespaces (no tables) can be removed. 890 * 891 * @param name namespace name 892 * @throws IOException 893 */ 894 void deleteNamespace(final String name) throws IOException; 895 896 /** 897 * Get a namespace descriptor by name 898 * 899 * @param name name of namespace descriptor 900 * @return A descriptor 901 * @throws IOException 902 */ 903 NamespaceDescriptor getNamespaceDescriptor(final String name) 904 throws IOException; 905 906 /** 907 * List available namespace descriptors 908 * 909 * @return List of descriptors 910 * @throws IOException 911 */ 912 NamespaceDescriptor[] listNamespaceDescriptors() 913 throws IOException; 914 915 /** 916 * Get list of table descriptors by namespace 917 * 918 * @param name namespace name 919 * @return A descriptor 920 * @throws IOException 921 */ 922 HTableDescriptor[] listTableDescriptorsByNamespace(final String name) 923 throws IOException; 924 925 /** 926 * Get list of table names by namespace 927 * 928 * @param name namespace name 929 * @return The list of table names in the namespace 930 * @throws IOException 931 */ 932 TableName[] listTableNamesByNamespace(final String name) 933 throws IOException; 934 935 /** 936 * Get the regions of a given table. 937 * 938 * @param tableName the name of the table 939 * @return List of {@link HRegionInfo}. 940 * @throws IOException 941 */ 942 List<HRegionInfo> getTableRegions(final TableName tableName) 943 throws IOException; 944 945 @Override 946 void close() throws IOException; 947 948 /** 949 * Get tableDescriptors 950 * 951 * @param tableNames List of table names 952 * @return HTD[] the tableDescriptor 953 * @throws IOException if a remote or network exception occurs 954 */ 955 HTableDescriptor[] getTableDescriptorsByTableName(List<TableName> tableNames) 956 throws IOException; 957 958 /** 959 * Get tableDescriptors 960 * 961 * @param names List of table names 962 * @return HTD[] the tableDescriptor 963 * @throws IOException if a remote or network exception occurs 964 */ 965 HTableDescriptor[] getTableDescriptors(List<String> names) 966 throws IOException; 967 968 /** 969 * abort a procedure 970 * @param procId ID of the procedure to abort 971 * @param mayInterruptIfRunning if the proc completed at least one step, should it be aborted? 972 * @return true if aborted, false if procedure already completed or does not exist 973 * @throws IOException 974 */ 975 boolean abortProcedure( 976 final long procId, 977 final boolean mayInterruptIfRunning) throws IOException; 978 979 /** 980 * List procedures 981 * @return procedure list 982 * @throws IOException 983 */ 984 ProcedureInfo[] listProcedures() throws IOException; 985 986 /** 987 * Abort a procedure but does not block and wait for it be completely removed. 988 * You can use Future.get(long, TimeUnit) to wait on the operation to complete. 989 * It may throw ExecutionException if there was an error while executing the operation 990 * or TimeoutException in case the wait timeout was not long enough to allow the 991 * operation to complete. 992 * 993 * @param procId ID of the procedure to abort 994 * @param mayInterruptIfRunning if the proc completed at least one step, should it be aborted? 995 * @return true if aborted, false if procedure already completed or does not exist 996 * @throws IOException 997 */ 998 Future<Boolean> abortProcedureAsync( 999 final long procId, 1000 final boolean mayInterruptIfRunning) throws IOException; 1001 1002 /** 1003 * Roll the log writer. I.e. for filesystem based write ahead logs, start writing to a new file. 1004 * 1005 * Note that the actual rolling of the log writer is asynchronous and may not be complete when 1006 * this method returns. As a side effect of this call, the named region server may schedule 1007 * store flushes at the request of the wal. 1008 * 1009 * @param serverName The servername of the regionserver. 1010 * @throws IOException if a remote or network exception occurs 1011 * @throws org.apache.hadoop.hbase.regionserver.wal.FailedLogCloseException 1012 */ 1013 void rollWALWriter(ServerName serverName) throws IOException, FailedLogCloseException; 1014 1015 /** 1016 * Helper delegage to getClusterStatus().getMasterCoprocessors(). 1017 * @return an array of master coprocessors 1018 * @see org.apache.hadoop.hbase.ClusterStatus#getMasterCoprocessors() 1019 */ 1020 String[] getMasterCoprocessors() throws IOException; 1021 1022 /** 1023 * Get the current compaction state of a table. It could be in a major compaction, a minor 1024 * compaction, both, or none. 1025 * 1026 * @param tableName table to examine 1027 * @return the current compaction state 1028 * @throws IOException if a remote or network exception occurs 1029 */ 1030 AdminProtos.GetRegionInfoResponse.CompactionState getCompactionState(final TableName tableName) 1031 throws IOException; 1032 1033 /** 1034 * Get the current compaction state of region. It could be in a major compaction, a minor 1035 * compaction, both, or none. 1036 * 1037 * @param regionName region to examine 1038 * @return the current compaction state 1039 * @throws IOException if a remote or network exception occurs 1040 */ 1041 AdminProtos.GetRegionInfoResponse.CompactionState getCompactionStateForRegion( 1042 final byte[] regionName) throws IOException; 1043 1044 /** 1045 * Get the timestamp of the last major compaction for the passed table 1046 * 1047 * The timestamp of the oldest HFile resulting from a major compaction of that table, 1048 * or 0 if no such HFile could be found. 1049 * 1050 * @param tableName table to examine 1051 * @return the last major compaction timestamp or 0 1052 * @throws IOException if a remote or network exception occurs 1053 */ 1054 long getLastMajorCompactionTimestamp(final TableName tableName) 1055 throws IOException; 1056 1057 /** 1058 * Get the timestamp of the last major compaction for the passed region. 1059 * 1060 * The timestamp of the oldest HFile resulting from a major compaction of that region, 1061 * or 0 if no such HFile could be found. 1062 * 1063 * @param regionName region to examine 1064 * @return the last major compaction timestamp or 0 1065 * @throws IOException if a remote or network exception occurs 1066 */ 1067 long getLastMajorCompactionTimestampForRegion(final byte[] regionName) 1068 throws IOException; 1069 1070 /** 1071 * Take a snapshot for the given table. If the table is enabled, a FLUSH-type snapshot will be 1072 * taken. If the table is disabled, an offline snapshot is taken. Snapshots are considered unique 1073 * based on <b>the name of the snapshot</b>. Attempts to take a snapshot with the same name (even 1074 * a different type or with different parameters) will fail with a {@link 1075 * org.apache.hadoop.hbase.snapshot.SnapshotCreationException} indicating the duplicate naming. 1076 * Snapshot names follow the same naming constraints as tables in HBase. See {@link 1077 * org.apache.hadoop.hbase.TableName#isLegalFullyQualifiedTableName(byte[])}. 1078 * 1079 * @param snapshotName name of the snapshot to be created 1080 * @param tableName name of the table for which snapshot is created 1081 * @throws IOException if a remote or network exception occurs 1082 * @throws org.apache.hadoop.hbase.snapshot.SnapshotCreationException if snapshot creation failed 1083 * @throws IllegalArgumentException if the snapshot request is formatted incorrectly 1084 */ 1085 void snapshot(final String snapshotName, final TableName tableName) 1086 throws IOException, SnapshotCreationException, IllegalArgumentException; 1087 1088 /** 1089 * public void snapshot(final String snapshotName, Create a timestamp consistent snapshot for the 1090 * given table. final byte[] tableName) throws IOException, Snapshots are considered unique based 1091 * on <b>the name of the snapshot</b>. Attempts to take a snapshot with the same name (even a 1092 * different type or with different parameters) will fail with a {@link SnapshotCreationException} 1093 * indicating the duplicate naming. Snapshot names follow the same naming constraints as tables in 1094 * HBase. 1095 * 1096 * @param snapshotName name of the snapshot to be created 1097 * @param tableName name of the table for which snapshot is created 1098 * @throws IOException if a remote or network exception occurs 1099 * @throws SnapshotCreationException if snapshot creation failed 1100 * @throws IllegalArgumentException if the snapshot request is formatted incorrectly 1101 */ 1102 void snapshot(final byte[] snapshotName, final TableName tableName) 1103 throws IOException, SnapshotCreationException, IllegalArgumentException; 1104 1105 /** 1106 * Create typed snapshot of the table. Snapshots are considered unique based on <b>the name of the 1107 * snapshot</b>. Attempts to take a snapshot with the same name (even a different type or with 1108 * different parameters) will fail with a {@link SnapshotCreationException} indicating the 1109 * duplicate naming. Snapshot names follow the same naming constraints as tables in HBase. See 1110 * {@link org.apache.hadoop.hbase.TableName#isLegalFullyQualifiedTableName(byte[])}. 1111 * 1112 * @param snapshotName name to give the snapshot on the filesystem. Must be unique from all other 1113 * snapshots stored on the cluster 1114 * @param tableName name of the table to snapshot 1115 * @param type type of snapshot to take 1116 * @throws IOException we fail to reach the master 1117 * @throws SnapshotCreationException if snapshot creation failed 1118 * @throws IllegalArgumentException if the snapshot request is formatted incorrectly 1119 */ 1120 void snapshot(final String snapshotName, 1121 final TableName tableName, 1122 HBaseProtos.SnapshotDescription.Type type) throws IOException, SnapshotCreationException, 1123 IllegalArgumentException; 1124 1125 /** 1126 * Take a snapshot and wait for the server to complete that snapshot (blocking). Only a single 1127 * snapshot should be taken at a time for an instance of HBase, or results may be undefined (you 1128 * can tell multiple HBase clusters to snapshot at the same time, but only one at a time for a 1129 * single cluster). Snapshots are considered unique based on <b>the name of the snapshot</b>. 1130 * Attempts to take a snapshot with the same name (even a different type or with different 1131 * parameters) will fail with a {@link SnapshotCreationException} indicating the duplicate naming. 1132 * Snapshot names follow the same naming constraints as tables in HBase. See {@link 1133 * org.apache.hadoop.hbase.TableName#isLegalFullyQualifiedTableName(byte[])}. You should probably 1134 * use {@link #snapshot(String, org.apache.hadoop.hbase.TableName)} or 1135 * {@link #snapshot(byte[], org.apache.hadoop.hbase.TableName)} unless you are sure about the type 1136 * of snapshot that you want to take. 1137 * 1138 * @param snapshot snapshot to take 1139 * @throws IOException or we lose contact with the master. 1140 * @throws SnapshotCreationException if snapshot failed to be taken 1141 * @throws IllegalArgumentException if the snapshot request is formatted incorrectly 1142 */ 1143 void snapshot(HBaseProtos.SnapshotDescription snapshot) 1144 throws IOException, SnapshotCreationException, IllegalArgumentException; 1145 1146 /** 1147 * Take a snapshot without waiting for the server to complete that snapshot (asynchronous) Only a 1148 * single snapshot should be taken at a time, or results may be undefined. 1149 * 1150 * @param snapshot snapshot to take 1151 * @return response from the server indicating the max time to wait for the snapshot 1152 * @throws IOException if the snapshot did not succeed or we lose contact with the master. 1153 * @throws SnapshotCreationException if snapshot creation failed 1154 * @throws IllegalArgumentException if the snapshot request is formatted incorrectly 1155 */ 1156 MasterProtos.SnapshotResponse takeSnapshotAsync(HBaseProtos.SnapshotDescription snapshot) 1157 throws IOException, SnapshotCreationException; 1158 1159 /** 1160 * Check the current state of the passed snapshot. There are three possible states: <ol> 1161 * <li>running - returns <tt>false</tt></li> <li>finished - returns <tt>true</tt></li> 1162 * <li>finished with error - throws the exception that caused the snapshot to fail</li> </ol> The 1163 * cluster only knows about the most recent snapshot. Therefore, if another snapshot has been 1164 * run/started since the snapshot your are checking, you will recieve an {@link 1165 * org.apache.hadoop.hbase.snapshot.UnknownSnapshotException}. 1166 * 1167 * @param snapshot description of the snapshot to check 1168 * @return <tt>true</tt> if the snapshot is completed, <tt>false</tt> if the snapshot is still 1169 * running 1170 * @throws IOException if we have a network issue 1171 * @throws org.apache.hadoop.hbase.snapshot.HBaseSnapshotException if the snapshot failed 1172 * @throws org.apache.hadoop.hbase.snapshot.UnknownSnapshotException if the requested snapshot is 1173 * unknown 1174 */ 1175 boolean isSnapshotFinished(final HBaseProtos.SnapshotDescription snapshot) 1176 throws IOException, HBaseSnapshotException, UnknownSnapshotException; 1177 1178 /** 1179 * Restore the specified snapshot on the original table. (The table must be disabled) If the 1180 * "hbase.snapshot.restore.take.failsafe.snapshot" configuration property is set to true, a 1181 * snapshot of the current table is taken before executing the restore operation. In case of 1182 * restore failure, the failsafe snapshot will be restored. If the restore completes without 1183 * problem the failsafe snapshot is deleted. 1184 * 1185 * @param snapshotName name of the snapshot to restore 1186 * @throws IOException if a remote or network exception occurs 1187 * @throws org.apache.hadoop.hbase.snapshot.RestoreSnapshotException if snapshot failed to be 1188 * restored 1189 * @throws IllegalArgumentException if the restore request is formatted incorrectly 1190 */ 1191 void restoreSnapshot(final byte[] snapshotName) throws IOException, RestoreSnapshotException; 1192 1193 /** 1194 * Restore the specified snapshot on the original table. (The table must be disabled) If the 1195 * "hbase.snapshot.restore.take.failsafe.snapshot" configuration property is set to true, a 1196 * snapshot of the current table is taken before executing the restore operation. In case of 1197 * restore failure, the failsafe snapshot will be restored. If the restore completes without 1198 * problem the failsafe snapshot is deleted. 1199 * 1200 * @param snapshotName name of the snapshot to restore 1201 * @throws IOException if a remote or network exception occurs 1202 * @throws RestoreSnapshotException if snapshot failed to be restored 1203 * @throws IllegalArgumentException if the restore request is formatted incorrectly 1204 */ 1205 void restoreSnapshot(final String snapshotName) throws IOException, RestoreSnapshotException; 1206 1207 /** 1208 * Restore the specified snapshot on the original table. (The table must be disabled) If 1209 * 'takeFailSafeSnapshot' is set to true, a snapshot of the current table is taken before 1210 * executing the restore operation. In case of restore failure, the failsafe snapshot will be 1211 * restored. If the restore completes without problem the failsafe snapshot is deleted. The 1212 * failsafe snapshot name is configurable by using the property 1213 * "hbase.snapshot.restore.failsafe.name". 1214 * 1215 * @param snapshotName name of the snapshot to restore 1216 * @param takeFailSafeSnapshot true if the failsafe snapshot should be taken 1217 * @throws IOException if a remote or network exception occurs 1218 * @throws RestoreSnapshotException if snapshot failed to be restored 1219 * @throws IllegalArgumentException if the restore request is formatted incorrectly 1220 */ 1221 void restoreSnapshot(final byte[] snapshotName, final boolean takeFailSafeSnapshot) 1222 throws IOException, RestoreSnapshotException; 1223 1224 /** 1225 * Restore the specified snapshot on the original table. (The table must be disabled) If 1226 * 'takeFailSafeSnapshot' is set to true, a snapshot of the current table is taken before 1227 * executing the restore operation. In case of restore failure, the failsafe snapshot will be 1228 * restored. If the restore completes without problem the failsafe snapshot is deleted. The 1229 * failsafe snapshot name is configurable by using the property 1230 * "hbase.snapshot.restore.failsafe.name". 1231 * 1232 * @param snapshotName name of the snapshot to restore 1233 * @param takeFailSafeSnapshot true if the failsafe snapshot should be taken 1234 * @throws IOException if a remote or network exception occurs 1235 * @throws RestoreSnapshotException if snapshot failed to be restored 1236 * @throws IllegalArgumentException if the restore request is formatted incorrectly 1237 */ 1238 void restoreSnapshot(final String snapshotName, boolean takeFailSafeSnapshot) 1239 throws IOException, RestoreSnapshotException; 1240 1241 /** 1242 * Restore the specified snapshot on the original table. (The table must be disabled) If 1243 * 'takeFailSafeSnapshot' is set to true, a snapshot of the current table is taken before 1244 * executing the restore operation. In case of restore failure, the failsafe snapshot will be 1245 * restored. If the restore completes without problem the failsafe snapshot is deleted. The 1246 * failsafe snapshot name is configurable by using the property 1247 * "hbase.snapshot.restore.failsafe.name". 1248 * @param snapshotName name of the snapshot to restore 1249 * @param takeFailSafeSnapshot true if the failsafe snapshot should be taken 1250 * @param restoreAcl true to restore acl of snapshot into table. 1251 * @throws IOException if a remote or network exception occurs 1252 * @throws RestoreSnapshotException if snapshot failed to be restored 1253 * @throws IllegalArgumentException if the restore request is formatted incorrectly 1254 */ 1255 void restoreSnapshot(final String snapshotName, boolean takeFailSafeSnapshot, boolean restoreAcl) 1256 throws IOException, RestoreSnapshotException; 1257 1258 /** 1259 * Create a new table by cloning the snapshot content. 1260 * 1261 * @param snapshotName name of the snapshot to be cloned 1262 * @param tableName name of the table where the snapshot will be restored 1263 * @throws IOException if a remote or network exception occurs 1264 * @throws TableExistsException if table to be created already exists 1265 * @throws RestoreSnapshotException if snapshot failed to be cloned 1266 * @throws IllegalArgumentException if the specified table has not a valid name 1267 */ 1268 void cloneSnapshot(final byte[] snapshotName, final TableName tableName) 1269 throws IOException, TableExistsException, RestoreSnapshotException; 1270 1271 /** 1272 * Create a new table by cloning the snapshot content. 1273 * 1274 * @param snapshotName name of the snapshot to be cloned 1275 * @param tableName name of the table where the snapshot will be restored 1276 * @throws IOException if a remote or network exception occurs 1277 * @throws TableExistsException if table to be created already exists 1278 * @throws RestoreSnapshotException if snapshot failed to be cloned 1279 * @throws IllegalArgumentException if the specified table has not a valid name 1280 */ 1281 void cloneSnapshot(final String snapshotName, final TableName tableName) 1282 throws IOException, TableExistsException, RestoreSnapshotException; 1283 1284 /** 1285 * Create a new table by cloning the snapshot content. 1286 * @param snapshotName name of the snapshot to be cloned 1287 * @param tableName name of the table where the snapshot will be restored 1288 * @param restoreAcl true to restore acl of snapshot into newly created table 1289 * @throws IOException if a remote or network exception occurs 1290 * @throws TableExistsException if table to be created already exists 1291 * @throws RestoreSnapshotException if snapshot failed to be cloned 1292 * @throws IllegalArgumentException if the specified table has not a valid name 1293 */ 1294 void cloneSnapshot(final String snapshotName, final TableName tableName, final boolean restoreAcl) 1295 throws IOException, TableExistsException, RestoreSnapshotException; 1296 1297 /** 1298 * Execute a distributed procedure on a cluster. 1299 * 1300 * @param signature A distributed procedure is uniquely identified by its signature (default the 1301 * root ZK node name of the procedure). 1302 * @param instance The instance name of the procedure. For some procedures, this parameter is 1303 * optional. 1304 * @param props Property/Value pairs of properties passing to the procedure 1305 * @throws IOException 1306 */ 1307 void execProcedure(String signature, String instance, Map<String, String> props) 1308 throws IOException; 1309 1310 /** 1311 * Execute a distributed procedure on a cluster. 1312 * 1313 * @param signature A distributed procedure is uniquely identified by its signature (default the 1314 * root ZK node name of the procedure). 1315 * @param instance The instance name of the procedure. For some procedures, this parameter is 1316 * optional. 1317 * @param props Property/Value pairs of properties passing to the procedure 1318 * @return data returned after procedure execution. null if no return data. 1319 * @throws IOException 1320 */ 1321 byte[] execProcedureWithRet(String signature, String instance, Map<String, String> props) 1322 throws IOException; 1323 1324 /** 1325 * Check the current state of the specified procedure. There are three possible states: <ol> 1326 * <li>running - returns <tt>false</tt></li> <li>finished - returns <tt>true</tt></li> 1327 * <li>finished with error - throws the exception that caused the procedure to fail</li> </ol> 1328 * 1329 * @param signature The signature that uniquely identifies a procedure 1330 * @param instance The instance name of the procedure 1331 * @param props Property/Value pairs of properties passing to the procedure 1332 * @return true if the specified procedure is finished successfully, false if it is still running 1333 * @throws IOException if the specified procedure finished with error 1334 */ 1335 boolean isProcedureFinished(String signature, String instance, Map<String, String> props) 1336 throws IOException; 1337 1338 /** 1339 * List completed snapshots. 1340 * 1341 * @return a list of snapshot descriptors for completed snapshots 1342 * @throws IOException if a network error occurs 1343 */ 1344 List<HBaseProtos.SnapshotDescription> listSnapshots() throws IOException; 1345 1346 /** 1347 * List all the completed snapshots matching the given regular expression. 1348 * 1349 * @param regex The regular expression to match against 1350 * @return - returns a List of SnapshotDescription 1351 * @throws IOException if a remote or network exception occurs 1352 */ 1353 List<HBaseProtos.SnapshotDescription> listSnapshots(String regex) throws IOException; 1354 1355 /** 1356 * List all the completed snapshots matching the given pattern. 1357 * 1358 * @param pattern The compiled regular expression to match against 1359 * @return - returns a List of SnapshotDescription 1360 * @throws IOException if a remote or network exception occurs 1361 */ 1362 List<HBaseProtos.SnapshotDescription> listSnapshots(Pattern pattern) throws IOException; 1363 1364 /** 1365 * Delete an existing snapshot. 1366 * 1367 * @param snapshotName name of the snapshot 1368 * @throws IOException if a remote or network exception occurs 1369 */ 1370 void deleteSnapshot(final byte[] snapshotName) throws IOException; 1371 1372 /** 1373 * Delete an existing snapshot. 1374 * 1375 * @param snapshotName name of the snapshot 1376 * @throws IOException if a remote or network exception occurs 1377 */ 1378 void deleteSnapshot(final String snapshotName) throws IOException; 1379 1380 /** 1381 * Delete existing snapshots whose names match the pattern passed. 1382 * 1383 * @param regex The regular expression to match against 1384 * @throws IOException if a remote or network exception occurs 1385 */ 1386 void deleteSnapshots(final String regex) throws IOException; 1387 1388 /** 1389 * Delete existing snapshots whose names match the pattern passed. 1390 * 1391 * @param pattern pattern for names of the snapshot to match 1392 * @throws IOException if a remote or network exception occurs 1393 */ 1394 void deleteSnapshots(final Pattern pattern) throws IOException; 1395 1396 /** 1397 * Apply the new quota settings. 1398 * @param quota the quota settings 1399 * @throws IOException if a remote or network exception occurs 1400 */ 1401 void setQuota(final QuotaSettings quota) throws IOException; 1402 1403 /** 1404 * Return a QuotaRetriever to list the quotas based on the filter. 1405 * @param filter the quota settings filter 1406 * @return the quota retriever 1407 * @throws IOException if a remote or network exception occurs 1408 */ 1409 QuotaRetriever getQuotaRetriever(final QuotaFilter filter) throws IOException; 1410 1411 /** 1412 * Creates and returns a {@link com.google.protobuf.RpcChannel} instance connected to the active 1413 * master. <p> The obtained {@link com.google.protobuf.RpcChannel} instance can be used to access 1414 * a published coprocessor {@link com.google.protobuf.Service} using standard protobuf service 1415 * invocations: </p> <div style="background-color: #cccccc; padding: 2px"> 1416 * <blockquote><pre> 1417 * CoprocessorRpcChannel channel = myAdmin.coprocessorService(); 1418 * MyService.BlockingInterface service = MyService.newBlockingStub(channel); 1419 * MyCallRequest request = MyCallRequest.newBuilder() 1420 * ... 1421 * .build(); 1422 * MyCallResponse response = service.myCall(null, request); 1423 * </pre></blockquote></div> 1424 * 1425 * @return A MasterCoprocessorRpcChannel instance 1426 */ 1427 CoprocessorRpcChannel coprocessorService(); 1428 1429 1430 /** 1431 * Creates and returns a {@link com.google.protobuf.RpcChannel} instance 1432 * connected to the passed region server. 1433 * 1434 * <p> 1435 * The obtained {@link com.google.protobuf.RpcChannel} instance can be used to access a published 1436 * coprocessor {@link com.google.protobuf.Service} using standard protobuf service invocations: 1437 * </p> 1438 * 1439 * <div style="background-color: #cccccc; padding: 2px"> 1440 * <blockquote><pre> 1441 * CoprocessorRpcChannel channel = myAdmin.coprocessorService(serverName); 1442 * MyService.BlockingInterface service = MyService.newBlockingStub(channel); 1443 * MyCallRequest request = MyCallRequest.newBuilder() 1444 * ... 1445 * .build(); 1446 * MyCallResponse response = service.myCall(null, request); 1447 * </pre></blockquote></div> 1448 * 1449 * @param sn the server name to which the endpoint call is made 1450 * @return A RegionServerCoprocessorRpcChannel instance 1451 */ 1452 CoprocessorRpcChannel coprocessorService(ServerName sn); 1453 1454 1455 /** 1456 * Update the configuration and trigger an online config change 1457 * on the regionserver 1458 * @param server : The server whose config needs to be updated. 1459 * @throws IOException 1460 */ 1461 void updateConfiguration(ServerName server) throws IOException; 1462 1463 1464 /** 1465 * Update the configuration and trigger an online config change 1466 * on all the regionservers 1467 * @throws IOException 1468 */ 1469 void updateConfiguration() throws IOException; 1470 1471 /** 1472 * Get the info port of the current master if one is available. 1473 * @return master info port 1474 * @throws IOException 1475 */ 1476 public int getMasterInfoPort() throws IOException; 1477 1478 /** 1479 * Compact a table. Asynchronous operation. 1480 * 1481 * @param tableName table to compact 1482 * @param compactType {@link org.apache.hadoop.hbase.client.Admin.CompactType} 1483 * @throws IOException 1484 * @throws InterruptedException 1485 */ 1486 void compact(final TableName tableName, CompactType compactType) 1487 throws IOException, InterruptedException; 1488 1489 /** 1490 * Compact a column family within a table. Asynchronous operation. 1491 * 1492 * @param tableName table to compact 1493 * @param columnFamily column family within a table 1494 * @param compactType {@link org.apache.hadoop.hbase.client.Admin.CompactType} 1495 * @throws IOException if not a mob column family or if a remote or network exception occurs 1496 * @throws InterruptedException 1497 */ 1498 void compact(final TableName tableName, final byte[] columnFamily, CompactType compactType) 1499 throws IOException, InterruptedException; 1500 1501 /** 1502 * Major compact a table. Asynchronous operation. 1503 * 1504 * @param tableName table to compact 1505 * @param compactType {@link org.apache.hadoop.hbase.client.Admin.CompactType} 1506 * @throws IOException 1507 * @throws InterruptedException 1508 */ 1509 void majorCompact(final TableName tableName, CompactType compactType) throws IOException, 1510 InterruptedException; 1511 1512 /** 1513 * Major compact a column family within a table. Asynchronous operation. 1514 * 1515 * @param tableName table to compact 1516 * @param columnFamily column family within a table 1517 * @param compactType {@link org.apache.hadoop.hbase.client.Admin.CompactType} 1518 * @throws IOException if not a mob column family or if a remote or network exception occurs 1519 * @throws InterruptedException 1520 */ 1521 void majorCompact(final TableName tableName, final byte[] columnFamily, CompactType compactType) 1522 throws IOException, InterruptedException; 1523 1524 /** 1525 * Get the current compaction state of a table. It could be in a compaction, or none. 1526 * 1527 * @param tableName table to examine 1528 * @param compactType {@link org.apache.hadoop.hbase.client.Admin.CompactType} 1529 * @return the current compaction state 1530 * @throws IOException if a remote or network exception occurs 1531 */ 1532 AdminProtos.GetRegionInfoResponse.CompactionState getCompactionState(final TableName tableName, 1533 CompactType compactType) throws IOException; 1534 1535 /** 1536 * Get Backup Admin interface 1537 * @return backup admin object 1538 * @throws IOException exception 1539 */ 1540 BackupAdmin getBackupAdmin() throws IOException; 1541 1542 /** 1543 * Currently, there are only two compact types: 1544 * {@code NORMAL} means do store files compaction; 1545 * {@code MOB} means do mob files compaction. 1546 * */ 1547 1548 @InterfaceAudience.Public 1549 @InterfaceStability.Unstable 1550 public enum CompactType { 1551 1552 NORMAL (0), 1553 MOB (1); 1554 1555 CompactType(int value) {} 1556 } 1557 1558 /** 1559 * Turn the Split or Merge switches on or off. 1560 * 1561 * @param enabled enabled or not 1562 * @param synchronous If true, it waits until current split() call, if outstanding, to return. 1563 * @param switchTypes switchType list {@link MasterSwitchType} 1564 * @return Previous switch value array 1565 */ 1566 boolean[] setSplitOrMergeEnabled(final boolean enabled, final boolean synchronous, 1567 final MasterSwitchType... switchTypes) throws IOException; 1568 1569 /** 1570 * Query the current state of the switch 1571 * 1572 * @return true if the switch is enabled, false otherwise. 1573 */ 1574 boolean isSplitOrMergeEnabled(final MasterSwitchType switchType) throws IOException; 1575 1576 @InterfaceAudience.Public 1577 @InterfaceStability.Evolving 1578 public enum MasterSwitchType { 1579 SPLIT, 1580 MERGE 1581 } 1582 1583 }