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 20 package org.apache.hadoop.hbase.coprocessor; 21 22 import java.io.IOException; 23 import java.util.List; 24 25 import org.apache.hadoop.classification.InterfaceAudience; 26 import org.apache.hadoop.classification.InterfaceStability; 27 import org.apache.hadoop.hbase.Coprocessor; 28 import org.apache.hadoop.hbase.TableName; 29 import org.apache.hadoop.hbase.HColumnDescriptor; 30 import org.apache.hadoop.hbase.HRegionInfo; 31 import org.apache.hadoop.hbase.HTableDescriptor; 32 import org.apache.hadoop.hbase.NamespaceDescriptor; 33 import org.apache.hadoop.hbase.ServerName; 34 import org.apache.hadoop.hbase.master.RegionPlan; 35 import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription; 36 37 /** 38 * Defines coprocessor hooks for interacting with operations on the 39 * {@link org.apache.hadoop.hbase.master.HMaster} process. 40 */ 41 @InterfaceAudience.Public 42 @InterfaceStability.Evolving 43 public interface MasterObserver extends Coprocessor { 44 45 /** 46 * Called before a new table is created by 47 * {@link org.apache.hadoop.hbase.master.HMaster}. Called as part of create 48 * table RPC call. 49 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 50 * @param ctx the environment to interact with the framework and master 51 * @param desc the HTableDescriptor for the table 52 * @param regions the initial regions created for the table 53 * @throws IOException 54 */ 55 void preCreateTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 56 HTableDescriptor desc, HRegionInfo[] regions) throws IOException; 57 58 /** 59 * Called after the createTable operation has been requested. Called as part 60 * of create table RPC call. 61 * @param ctx the environment to interact with the framework and master 62 * @param desc the HTableDescriptor for the table 63 * @param regions the initial regions created for the table 64 * @throws IOException 65 */ 66 void postCreateTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 67 HTableDescriptor desc, HRegionInfo[] regions) throws IOException; 68 /** 69 * Called before a new table is created by 70 * {@link org.apache.hadoop.hbase.master.HMaster}. Called as part of create 71 * table handler and it is async to the create RPC call. 72 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 73 * @param ctx the environment to interact with the framework and master 74 * @param desc the HTableDescriptor for the table 75 * @param regions the initial regions created for the table 76 * @throws IOException 77 */ 78 void preCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> 79 ctx, HTableDescriptor desc, HRegionInfo[] regions) throws IOException; 80 81 /** 82 * Called after the createTable operation has been requested. Called as part 83 * of create table RPC call. Called as part of create table handler and 84 * it is async to the create RPC call. 85 * @param ctx the environment to interact with the framework and master 86 * @param desc the HTableDescriptor for the table 87 * @param regions the initial regions created for the table 88 * @throws IOException 89 */ 90 void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> 91 ctx, HTableDescriptor desc, HRegionInfo[] regions) throws IOException; 92 93 /** 94 * Called before {@link org.apache.hadoop.hbase.master.HMaster} deletes a 95 * table. Called as part of delete table RPC call. 96 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 97 * @param ctx the environment to interact with the framework and master 98 * @param tableName the name of the table 99 */ 100 void preDeleteTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 101 TableName tableName) throws IOException; 102 103 /** 104 * Called after the deleteTable operation has been requested. Called as part 105 * of delete table RPC call. 106 * @param ctx the environment to interact with the framework and master 107 * @param tableName the name of the table 108 */ 109 void postDeleteTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 110 TableName tableName) throws IOException; 111 112 /** 113 * Called before {@link org.apache.hadoop.hbase.master.HMaster} deletes a 114 * table. Called as part of delete table handler and 115 * it is async to the delete RPC call. 116 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 117 * @param ctx the environment to interact with the framework and master 118 * @param tableName the name of the table 119 */ 120 void preDeleteTableHandler( 121 final ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName) 122 throws IOException; 123 124 /** 125 * Called after {@link org.apache.hadoop.hbase.master.HMaster} deletes a 126 * table. Called as part of delete table handler and it is async to the 127 * delete RPC call. 128 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 129 * @param ctx the environment to interact with the framework and master 130 * @param tableName the name of the table 131 */ 132 void postDeleteTableHandler( 133 final ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName) 134 throws IOException; 135 136 /** 137 * Called prior to modifying a table's properties. Called as part of modify 138 * table RPC call. 139 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 140 * @param ctx the environment to interact with the framework and master 141 * @param tableName the name of the table 142 * @param htd the HTableDescriptor 143 */ 144 void preModifyTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 145 final TableName tableName, HTableDescriptor htd) throws IOException; 146 147 /** 148 * Called after the modifyTable operation has been requested. Called as part 149 * of modify table RPC call. 150 * @param ctx the environment to interact with the framework and master 151 * @param tableName the name of the table 152 * @param htd the HTableDescriptor 153 */ 154 void postModifyTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 155 final TableName tableName, HTableDescriptor htd) throws IOException; 156 157 /** 158 * Called prior to modifying a table's properties. Called as part of modify 159 * table handler and it is async to the modify table RPC call. 160 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 161 * @param ctx the environment to interact with the framework and master 162 * @param tableName the name of the table 163 * @param htd the HTableDescriptor 164 */ 165 void preModifyTableHandler( 166 final ObserverContext<MasterCoprocessorEnvironment> ctx, 167 final TableName tableName, HTableDescriptor htd) throws IOException; 168 169 /** 170 * Called after to modifying a table's properties. Called as part of modify 171 * table handler and it is async to the modify table RPC call. 172 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 173 * @param ctx the environment to interact with the framework and master 174 * @param tableName the name of the table 175 * @param htd the HTableDescriptor 176 */ 177 void postModifyTableHandler( 178 final ObserverContext<MasterCoprocessorEnvironment> ctx, 179 final TableName tableName, HTableDescriptor htd) throws IOException; 180 181 /** 182 * Called prior to adding a new column family to the table. Called as part of 183 * add column RPC call. 184 * @param ctx the environment to interact with the framework and master 185 * @param tableName the name of the table 186 * @param column the HColumnDescriptor 187 */ 188 void preAddColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 189 TableName tableName, HColumnDescriptor column) throws IOException; 190 191 /** 192 * Called after the new column family has been created. Called as part of 193 * add column RPC call. 194 * @param ctx the environment to interact with the framework and master 195 * @param tableName the name of the table 196 * @param column the HColumnDescriptor 197 */ 198 void postAddColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 199 TableName tableName, HColumnDescriptor column) throws IOException; 200 201 /** 202 * Called prior to adding a new column family to the table. Called as part of 203 * add column handler. 204 * @param ctx the environment to interact with the framework and master 205 * @param tableName the name of the table 206 * @param column the HColumnDescriptor 207 */ 208 void preAddColumnHandler( 209 final ObserverContext<MasterCoprocessorEnvironment> ctx, 210 TableName tableName, HColumnDescriptor column) throws IOException; 211 212 /** 213 * Called after the new column family has been created. Called as part of 214 * add column handler. 215 * @param ctx the environment to interact with the framework and master 216 * @param tableName the name of the table 217 * @param column the HColumnDescriptor 218 */ 219 void postAddColumnHandler( 220 final ObserverContext<MasterCoprocessorEnvironment> ctx, 221 TableName tableName, HColumnDescriptor column) throws IOException; 222 223 /** 224 * Called prior to modifying a column family's attributes. Called as part of 225 * modify column RPC call. 226 * @param ctx the environment to interact with the framework and master 227 * @param tableName the name of the table 228 * @param descriptor the HColumnDescriptor 229 */ 230 void preModifyColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 231 TableName tableName, HColumnDescriptor descriptor) throws IOException; 232 233 /** 234 * Called after the column family has been updated. Called as part of modify 235 * column RPC call. 236 * @param ctx the environment to interact with the framework and master 237 * @param tableName the name of the table 238 * @param descriptor the HColumnDescriptor 239 */ 240 void postModifyColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 241 TableName tableName, HColumnDescriptor descriptor) throws IOException; 242 243 /** 244 * Called prior to modifying a column family's attributes. Called as part of 245 * modify column handler. 246 * @param ctx the environment to interact with the framework and master 247 * @param tableName the name of the table 248 * @param descriptor the HColumnDescriptor 249 */ 250 void preModifyColumnHandler( 251 final ObserverContext<MasterCoprocessorEnvironment> ctx, 252 TableName tableName, HColumnDescriptor descriptor) throws IOException; 253 254 /** 255 * Called after the column family has been updated. Called as part of modify 256 * column handler. 257 * @param ctx the environment to interact with the framework and master 258 * @param tableName the name of the table 259 * @param descriptor the HColumnDescriptor 260 */ 261 void postModifyColumnHandler( 262 final ObserverContext<MasterCoprocessorEnvironment> ctx, 263 TableName tableName, HColumnDescriptor descriptor) throws IOException; 264 265 266 /** 267 * Called prior to deleting the entire column family. Called as part of 268 * delete column RPC call. 269 * @param ctx the environment to interact with the framework and master 270 * @param tableName the name of the table 271 * @param c the column 272 */ 273 void preDeleteColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 274 final TableName tableName, final byte[] c) throws IOException; 275 276 /** 277 * Called after the column family has been deleted. Called as part of delete 278 * column RPC call. 279 * @param ctx the environment to interact with the framework and master 280 * @param tableName the name of the table 281 * @param c the column 282 */ 283 void postDeleteColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 284 final TableName tableName, final byte[] c) throws IOException; 285 286 /** 287 * Called prior to deleting the entire column family. Called as part of 288 * delete column handler. 289 * @param ctx the environment to interact with the framework and master 290 * @param tableName the name of the table 291 * @param c the column 292 */ 293 void preDeleteColumnHandler( 294 final ObserverContext<MasterCoprocessorEnvironment> ctx, 295 final TableName tableName, final byte[] c) throws IOException; 296 297 /** 298 * Called after the column family has been deleted. Called as part of 299 * delete column handler. 300 * @param ctx the environment to interact with the framework and master 301 * @param tableName the name of the table 302 * @param c the column 303 */ 304 void postDeleteColumnHandler( 305 final ObserverContext<MasterCoprocessorEnvironment> ctx, 306 final TableName tableName, final byte[] c) throws IOException; 307 308 /** 309 * Called prior to enabling a table. Called as part of enable table RPC call. 310 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 311 * @param ctx the environment to interact with the framework and master 312 * @param tableName the name of the table 313 */ 314 void preEnableTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 315 final TableName tableName) throws IOException; 316 317 /** 318 * Called after the enableTable operation has been requested. Called as part 319 * of enable table RPC call. 320 * @param ctx the environment to interact with the framework and master 321 * @param tableName the name of the table 322 */ 323 void postEnableTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 324 final TableName tableName) throws IOException; 325 326 /** 327 * Called prior to enabling a table. Called as part of enable table handler 328 * and it is async to the enable table RPC call. 329 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 330 * @param ctx the environment to interact with the framework and master 331 * @param tableName the name of the table 332 */ 333 void preEnableTableHandler( 334 final ObserverContext<MasterCoprocessorEnvironment> ctx, 335 final TableName tableName) throws IOException; 336 337 /** 338 * Called after the enableTable operation has been requested. Called as part 339 * of enable table handler and it is async to the enable table RPC call. 340 * @param ctx the environment to interact with the framework and master 341 * @param tableName the name of the table 342 */ 343 void postEnableTableHandler( 344 final ObserverContext<MasterCoprocessorEnvironment> ctx, 345 final TableName tableName) throws IOException; 346 347 /** 348 * Called prior to disabling a table. Called as part of disable table RPC 349 * call. 350 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 351 * @param ctx the environment to interact with the framework and master 352 * @param tableName the name of the table 353 */ 354 void preDisableTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 355 final TableName tableName) throws IOException; 356 357 /** 358 * Called after the disableTable operation has been requested. Called as part 359 * of disable table RPC call. 360 * @param ctx the environment to interact with the framework and master 361 * @param tableName the name of the table 362 */ 363 void postDisableTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 364 final TableName tableName) throws IOException; 365 366 /** 367 * Called prior to disabling a table. Called as part of disable table handler 368 * and it is asyn to the disable table RPC call. 369 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 370 * @param ctx the environment to interact with the framework and master 371 * @param tableName the name of the table 372 */ 373 void preDisableTableHandler( 374 final ObserverContext<MasterCoprocessorEnvironment> ctx, 375 final TableName tableName) throws IOException; 376 377 /** 378 * Called after the disableTable operation has been requested. Called as part 379 * of disable table handler and it is asyn to the disable table RPC call. 380 * @param ctx the environment to interact with the framework and master 381 * @param tableName the name of the table 382 */ 383 void postDisableTableHandler( 384 final ObserverContext<MasterCoprocessorEnvironment> ctx, 385 final TableName tableName) throws IOException; 386 387 /** 388 * Called prior to moving a given region from one region server to another. 389 * @param ctx the environment to interact with the framework and master 390 * @param region the HRegionInfo 391 * @param srcServer the source ServerName 392 * @param destServer the destination ServerName 393 */ 394 void preMove(final ObserverContext<MasterCoprocessorEnvironment> ctx, 395 final HRegionInfo region, final ServerName srcServer, 396 final ServerName destServer) 397 throws IOException; 398 399 /** 400 * Called after the region move has been requested. 401 * @param ctx the environment to interact with the framework and master 402 * @param region the HRegionInfo 403 * @param srcServer the source ServerName 404 * @param destServer the destination ServerName 405 */ 406 void postMove(final ObserverContext<MasterCoprocessorEnvironment> ctx, 407 final HRegionInfo region, final ServerName srcServer, 408 final ServerName destServer) 409 throws IOException; 410 411 /** 412 * Called prior to assigning a specific region. 413 * @param ctx the environment to interact with the framework and master 414 * @param regionInfo the regionInfo of the region 415 */ 416 void preAssign(final ObserverContext<MasterCoprocessorEnvironment> ctx, 417 final HRegionInfo regionInfo) throws IOException; 418 419 /** 420 * Called after the region assignment has been requested. 421 * @param ctx the environment to interact with the framework and master 422 * @param regionInfo the regionInfo of the region 423 */ 424 void postAssign(final ObserverContext<MasterCoprocessorEnvironment> ctx, 425 final HRegionInfo regionInfo) throws IOException; 426 427 /** 428 * Called prior to unassigning a given region. 429 * @param ctx the environment to interact with the framework and master 430 * @param regionInfo 431 * @param force whether to force unassignment or not 432 */ 433 void preUnassign(final ObserverContext<MasterCoprocessorEnvironment> ctx, 434 final HRegionInfo regionInfo, final boolean force) throws IOException; 435 436 /** 437 * Called after the region unassignment has been requested. 438 * @param ctx the environment to interact with the framework and master 439 * @param regionInfo 440 * @param force whether to force unassignment or not 441 */ 442 void postUnassign(final ObserverContext<MasterCoprocessorEnvironment> ctx, 443 final HRegionInfo regionInfo, final boolean force) throws IOException; 444 445 /** 446 * Called prior to marking a given region as offline. <code>ctx.bypass()</code> will not have any 447 * impact on this hook. 448 * @param ctx the environment to interact with the framework and master 449 * @param regionInfo 450 */ 451 void preRegionOffline(final ObserverContext<MasterCoprocessorEnvironment> ctx, 452 final HRegionInfo regionInfo) throws IOException; 453 454 /** 455 * Called after the region has been marked offline. 456 * @param ctx the environment to interact with the framework and master 457 * @param regionInfo 458 */ 459 void postRegionOffline(final ObserverContext<MasterCoprocessorEnvironment> ctx, 460 final HRegionInfo regionInfo) throws IOException; 461 462 /** 463 * Called prior to requesting rebalancing of the cluster regions, though after 464 * the initial checks for regions in transition and the balance switch flag. 465 * @param ctx the environment to interact with the framework and master 466 */ 467 void preBalance(final ObserverContext<MasterCoprocessorEnvironment> ctx) 468 throws IOException; 469 470 /** 471 * Called after the balancing plan has been submitted. 472 * @param ctx the environment to interact with the framework and master 473 * @param plans the RegionPlans which master has executed. RegionPlan serves as hint 474 * as for the final destination for the underlying region but may not represent the 475 * final state of assignment 476 */ 477 void postBalance(final ObserverContext<MasterCoprocessorEnvironment> ctx, List<RegionPlan> plans) 478 throws IOException; 479 480 /** 481 * Called prior to modifying the flag used to enable/disable region balancing. 482 * @param ctx the coprocessor instance's environment 483 * @param newValue the new flag value submitted in the call 484 */ 485 boolean preBalanceSwitch(final ObserverContext<MasterCoprocessorEnvironment> ctx, 486 final boolean newValue) throws IOException; 487 488 /** 489 * Called after the flag to enable/disable balancing has changed. 490 * @param ctx the coprocessor instance's environment 491 * @param oldValue the previously set balanceSwitch value 492 * @param newValue the newly set balanceSwitch value 493 */ 494 void postBalanceSwitch(final ObserverContext<MasterCoprocessorEnvironment> ctx, 495 final boolean oldValue, final boolean newValue) throws IOException; 496 497 /** 498 * Called prior to shutting down the full HBase cluster, including this 499 * {@link org.apache.hadoop.hbase.master.HMaster} process. 500 */ 501 void preShutdown(final ObserverContext<MasterCoprocessorEnvironment> ctx) 502 throws IOException; 503 504 505 /** 506 * Called immediately prior to stopping this 507 * {@link org.apache.hadoop.hbase.master.HMaster} process. 508 */ 509 void preStopMaster(final ObserverContext<MasterCoprocessorEnvironment> ctx) 510 throws IOException; 511 512 /** 513 * Called immediately after an active master instance has completed 514 * initialization. Will not be called on standby master instances unless 515 * they take over the active role. 516 */ 517 void postStartMaster(final ObserverContext<MasterCoprocessorEnvironment> ctx) 518 throws IOException; 519 520 /** 521 * Called before a new snapshot is taken. 522 * Called as part of snapshot RPC call. 523 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 524 * @param ctx the environment to interact with the framework and master 525 * @param snapshot the SnapshotDescriptor for the snapshot 526 * @param hTableDescriptor the hTableDescriptor of the table to snapshot 527 * @throws IOException 528 */ 529 void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 530 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 531 throws IOException; 532 533 /** 534 * Called after the snapshot operation has been requested. 535 * Called as part of snapshot RPC call. 536 * @param ctx the environment to interact with the framework and master 537 * @param snapshot the SnapshotDescriptor for the snapshot 538 * @param hTableDescriptor the hTableDescriptor of the table to snapshot 539 * @throws IOException 540 */ 541 void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 542 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 543 throws IOException; 544 545 /** 546 * Called before a snapshot is cloned. 547 * Called as part of restoreSnapshot RPC call. 548 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 549 * @param ctx the environment to interact with the framework and master 550 * @param snapshot the SnapshotDescriptor for the snapshot 551 * @param hTableDescriptor the hTableDescriptor of the table to create 552 * @throws IOException 553 */ 554 void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 555 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 556 throws IOException; 557 558 /** 559 * Called after a snapshot clone operation has been requested. 560 * Called as part of restoreSnapshot RPC call. 561 * @param ctx the environment to interact with the framework and master 562 * @param snapshot the SnapshotDescriptor for the snapshot 563 * @param hTableDescriptor the hTableDescriptor of the table to create 564 * @throws IOException 565 */ 566 void postCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 567 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 568 throws IOException; 569 570 /** 571 * Called before a snapshot is restored. 572 * Called as part of restoreSnapshot RPC call. 573 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 574 * @param ctx the environment to interact with the framework and master 575 * @param snapshot the SnapshotDescriptor for the snapshot 576 * @param hTableDescriptor the hTableDescriptor of the table to restore 577 * @throws IOException 578 */ 579 void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 580 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 581 throws IOException; 582 583 /** 584 * Called after a snapshot restore operation has been requested. 585 * Called as part of restoreSnapshot RPC call. 586 * @param ctx the environment to interact with the framework and master 587 * @param snapshot the SnapshotDescriptor for the snapshot 588 * @param hTableDescriptor the hTableDescriptor of the table to restore 589 * @throws IOException 590 */ 591 void postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 592 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 593 throws IOException; 594 595 /** 596 * Called before a snapshot is deleted. 597 * Called as part of deleteSnapshot RPC call. 598 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 599 * @param ctx the environment to interact with the framework and master 600 * @param snapshot the SnapshotDescriptor of the snapshot to delete 601 * @throws IOException 602 */ 603 void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 604 final SnapshotDescription snapshot) throws IOException; 605 606 /** 607 * Called after the delete snapshot operation has been requested. 608 * Called as part of deleteSnapshot RPC call. 609 * @param ctx the environment to interact with the framework and master 610 * @param snapshot the SnapshotDescriptor of the snapshot to delete 611 * @throws IOException 612 */ 613 void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 614 final SnapshotDescription snapshot) throws IOException; 615 616 /** 617 * Called before a getTableDescriptors request has been processed. 618 * @param ctx the environment to interact with the framework and master 619 * @param tableNamesList the list of table names, or null if querying for all 620 * @param descriptors an empty list, can be filled with what to return if bypassing 621 * @throws IOException 622 */ 623 void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, 624 List<TableName> tableNamesList, 625 List<HTableDescriptor> descriptors) throws IOException; 626 627 /** 628 * Called after a getTableDescriptors request has been processed. 629 * @param ctx the environment to interact with the framework and master 630 * @param descriptors the list of descriptors about to be returned 631 * @throws IOException 632 */ 633 void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, 634 List<HTableDescriptor> descriptors) throws IOException; 635 636 /** 637 * Called before a new namespace is created by 638 * {@link org.apache.hadoop.hbase.master.HMaster}. 639 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 640 * @param ctx the environment to interact with the framework and master 641 * @param ns the NamespaceDescriptor for the table 642 * @throws IOException 643 */ 644 void preCreateNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 645 NamespaceDescriptor ns) throws IOException; 646 /** 647 * Called after the createNamespace operation has been requested. 648 * @param ctx the environment to interact with the framework and master 649 * @param ns the NamespaceDescriptor for the table 650 * @throws IOException 651 */ 652 void postCreateNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 653 NamespaceDescriptor ns) throws IOException; 654 655 /** 656 * Called before {@link org.apache.hadoop.hbase.master.HMaster} deletes a 657 * namespace 658 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 659 * @param ctx the environment to interact with the framework and master 660 * @param namespace the name of the namespace 661 */ 662 void preDeleteNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 663 String namespace) throws IOException; 664 665 /** 666 * Called after the deleteNamespace operation has been requested. 667 * @param ctx the environment to interact with the framework and master 668 * @param namespace the name of the namespace 669 */ 670 void postDeleteNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 671 String namespace) throws IOException; 672 673 /** 674 * Called prior to modifying a namespace's properties. 675 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 676 * @param ctx the environment to interact with the framework and master 677 * @param ns the NamespaceDescriptor 678 */ 679 void preModifyNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 680 NamespaceDescriptor ns) throws IOException; 681 682 /** 683 * Called after the modifyNamespace operation has been requested. 684 * @param ctx the environment to interact with the framework and master 685 * @param ns the NamespaceDescriptor 686 */ 687 void postModifyNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 688 NamespaceDescriptor ns) throws IOException; 689 }