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 com.google.common.net.HostAndPort; 23 24 import java.io.IOException; 25 import java.util.List; 26 import java.util.Set; 27 28 import org.apache.hadoop.hbase.classification.InterfaceAudience; 29 import org.apache.hadoop.hbase.classification.InterfaceStability; 30 import org.apache.hadoop.hbase.Coprocessor; 31 import org.apache.hadoop.hbase.HBaseInterfaceAudience; 32 import org.apache.hadoop.hbase.ProcedureInfo; 33 import org.apache.hadoop.hbase.TableName; 34 import org.apache.hadoop.hbase.HColumnDescriptor; 35 import org.apache.hadoop.hbase.HRegionInfo; 36 import org.apache.hadoop.hbase.HTableDescriptor; 37 import org.apache.hadoop.hbase.NamespaceDescriptor; 38 import org.apache.hadoop.hbase.ServerName; 39 import org.apache.hadoop.hbase.master.RegionPlan; 40 import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv; 41 import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; 42 import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription; 43 import org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas; 44 45 /** 46 * Defines coprocessor hooks for interacting with operations on the 47 * {@link org.apache.hadoop.hbase.master.HMaster} process. 48 */ 49 @InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.COPROC) 50 @InterfaceStability.Evolving 51 public interface MasterObserver extends Coprocessor { 52 53 /** 54 * Called before a new table is created by 55 * {@link org.apache.hadoop.hbase.master.HMaster}. Called as part of create 56 * table RPC call. 57 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 58 * @param ctx the environment to interact with the framework and master 59 * @param desc the HTableDescriptor for the table 60 * @param regions the initial regions created for the table 61 * @throws IOException 62 */ 63 void preCreateTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 64 HTableDescriptor desc, HRegionInfo[] regions) throws IOException; 65 66 /** 67 * Called after the createTable operation has been requested. Called as part 68 * of create table RPC call. 69 * @param ctx the environment to interact with the framework and master 70 * @param desc the HTableDescriptor for the table 71 * @param regions the initial regions created for the table 72 * @throws IOException 73 */ 74 void postCreateTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 75 HTableDescriptor desc, HRegionInfo[] regions) throws IOException; 76 /** 77 * Called before a new table is created by 78 * {@link org.apache.hadoop.hbase.master.HMaster}. Called as part of create 79 * table handler and it is async to the create RPC call. 80 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 81 * @param ctx the environment to interact with the framework and master 82 * @param desc the HTableDescriptor for the table 83 * @param regions the initial regions created for the table 84 * @throws IOException 85 */ 86 void preCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> 87 ctx, HTableDescriptor desc, HRegionInfo[] regions) throws IOException; 88 89 /** 90 * Called after the createTable operation has been requested. Called as part 91 * of create table RPC call. Called as part of create table handler and 92 * it is async to the create RPC call. 93 * @param ctx the environment to interact with the framework and master 94 * @param desc the HTableDescriptor for the table 95 * @param regions the initial regions created for the table 96 * @throws IOException 97 */ 98 void postCreateTableHandler(final ObserverContext<MasterCoprocessorEnvironment> 99 ctx, HTableDescriptor desc, HRegionInfo[] regions) throws IOException; 100 101 /** 102 * Called before {@link org.apache.hadoop.hbase.master.HMaster} deletes a 103 * table. Called as part of delete table RPC call. 104 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 105 * @param ctx the environment to interact with the framework and master 106 * @param tableName the name of the table 107 */ 108 void preDeleteTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 109 TableName tableName) throws IOException; 110 111 /** 112 * Called after the deleteTable operation has been requested. Called as part 113 * of delete table RPC call. 114 * @param ctx the environment to interact with the framework and master 115 * @param tableName the name of the table 116 */ 117 void postDeleteTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 118 TableName tableName) throws IOException; 119 120 /** 121 * Called before {@link org.apache.hadoop.hbase.master.HMaster} deletes a 122 * table. Called as part of delete table handler and 123 * it is async to the delete RPC call. 124 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 125 * @param ctx the environment to interact with the framework and master 126 * @param tableName the name of the table 127 */ 128 void preDeleteTableHandler( 129 final ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName) 130 throws IOException; 131 132 /** 133 * Called after {@link org.apache.hadoop.hbase.master.HMaster} deletes a 134 * table. Called as part of delete table handler and it is async to the 135 * delete RPC call. 136 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 137 * @param ctx the environment to interact with the framework and master 138 * @param tableName the name of the table 139 */ 140 void postDeleteTableHandler( 141 final ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName) 142 throws IOException; 143 144 145 /** 146 * Called before {@link org.apache.hadoop.hbase.master.HMaster} truncates a 147 * table. Called as part of truncate table RPC call. 148 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 149 * @param ctx the environment to interact with the framework and master 150 * @param tableName the name of the table 151 */ 152 void preTruncateTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 153 TableName tableName) throws IOException; 154 155 /** 156 * Called after the truncateTable operation has been requested. Called as part 157 * of truncate table RPC call. 158 * The truncate is synchronous, so this method will be called when the 159 * truncate operation is terminated. 160 * @param ctx the environment to interact with the framework and master 161 * @param tableName the name of the table 162 */ 163 void postTruncateTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 164 TableName tableName) throws IOException; 165 166 /** 167 * Called before {@link org.apache.hadoop.hbase.master.HMaster} truncates a 168 * table. Called as part of truncate table handler and it is sync 169 * to the truncate RPC call. 170 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 171 * @param ctx the environment to interact with the framework and master 172 * @param tableName the name of the table 173 */ 174 void preTruncateTableHandler( 175 final ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName) 176 throws IOException; 177 178 /** 179 * Called after {@link org.apache.hadoop.hbase.master.HMaster} truncates a 180 * table. Called as part of truncate table handler and it is sync to the 181 * truncate RPC call. 182 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 183 * @param ctx the environment to interact with the framework and master 184 * @param tableName the name of the table 185 */ 186 void postTruncateTableHandler( 187 final ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName) 188 throws IOException; 189 190 /** 191 * Called prior to modifying a table's properties. Called as part of modify 192 * table RPC call. 193 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 194 * @param ctx the environment to interact with the framework and master 195 * @param tableName the name of the table 196 * @param htd the HTableDescriptor 197 */ 198 void preModifyTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 199 final TableName tableName, HTableDescriptor htd) throws IOException; 200 201 /** 202 * Called after the modifyTable operation has been requested. Called as part 203 * of modify table RPC call. 204 * @param ctx the environment to interact with the framework and master 205 * @param tableName the name of the table 206 * @param htd the HTableDescriptor 207 */ 208 void postModifyTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 209 final TableName tableName, HTableDescriptor htd) throws IOException; 210 211 /** 212 * Called prior to modifying a table's properties. Called as part of modify 213 * table handler and it is async to the modify table RPC call. 214 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 215 * @param ctx the environment to interact with the framework and master 216 * @param tableName the name of the table 217 * @param htd the HTableDescriptor 218 */ 219 void preModifyTableHandler( 220 final ObserverContext<MasterCoprocessorEnvironment> ctx, 221 final TableName tableName, HTableDescriptor htd) throws IOException; 222 223 /** 224 * Called after to modifying a table's properties. Called as part of modify 225 * table handler and it is async to the modify table RPC call. 226 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 227 * @param ctx the environment to interact with the framework and master 228 * @param tableName the name of the table 229 * @param htd the HTableDescriptor 230 */ 231 void postModifyTableHandler( 232 final ObserverContext<MasterCoprocessorEnvironment> ctx, 233 final TableName tableName, HTableDescriptor htd) throws IOException; 234 235 /** 236 * Called prior to adding a new column family to the table. Called as part of 237 * add column RPC call. 238 * @param ctx the environment to interact with the framework and master 239 * @param tableName the name of the table 240 * @param column the HColumnDescriptor 241 */ 242 void preAddColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 243 TableName tableName, HColumnDescriptor column) throws IOException; 244 245 /** 246 * Called after the new column family has been created. Called as part of 247 * add column RPC call. 248 * @param ctx the environment to interact with the framework and master 249 * @param tableName the name of the table 250 * @param column the HColumnDescriptor 251 */ 252 void postAddColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 253 TableName tableName, HColumnDescriptor column) throws IOException; 254 255 /** 256 * Called prior to adding a new column family to the table. Called as part of 257 * add column handler. 258 * @param ctx the environment to interact with the framework and master 259 * @param tableName the name of the table 260 * @param column the HColumnDescriptor 261 */ 262 void preAddColumnHandler( 263 final ObserverContext<MasterCoprocessorEnvironment> ctx, 264 TableName tableName, HColumnDescriptor column) throws IOException; 265 266 /** 267 * Called after the new column family has been created. Called as part of 268 * add column handler. 269 * @param ctx the environment to interact with the framework and master 270 * @param tableName the name of the table 271 * @param column the HColumnDescriptor 272 */ 273 void postAddColumnHandler( 274 final ObserverContext<MasterCoprocessorEnvironment> ctx, 275 TableName tableName, HColumnDescriptor column) throws IOException; 276 277 /** 278 * Called prior to modifying a column family's attributes. Called as part of 279 * modify column RPC call. 280 * @param ctx the environment to interact with the framework and master 281 * @param tableName the name of the table 282 * @param descriptor the HColumnDescriptor 283 */ 284 void preModifyColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 285 TableName tableName, HColumnDescriptor descriptor) throws IOException; 286 287 /** 288 * Called after the column family has been updated. Called as part of modify 289 * column RPC call. 290 * @param ctx the environment to interact with the framework and master 291 * @param tableName the name of the table 292 * @param descriptor the HColumnDescriptor 293 */ 294 void postModifyColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 295 TableName tableName, HColumnDescriptor descriptor) throws IOException; 296 297 /** 298 * Called prior to modifying a column family's attributes. Called as part of 299 * modify column handler. 300 * @param ctx the environment to interact with the framework and master 301 * @param tableName the name of the table 302 * @param descriptor the HColumnDescriptor 303 */ 304 void preModifyColumnHandler( 305 final ObserverContext<MasterCoprocessorEnvironment> ctx, 306 TableName tableName, HColumnDescriptor descriptor) throws IOException; 307 308 /** 309 * Called after the column family has been updated. Called as part of modify 310 * column handler. 311 * @param ctx the environment to interact with the framework and master 312 * @param tableName the name of the table 313 * @param descriptor the HColumnDescriptor 314 */ 315 void postModifyColumnHandler( 316 final ObserverContext<MasterCoprocessorEnvironment> ctx, 317 TableName tableName, HColumnDescriptor descriptor) throws IOException; 318 319 320 /** 321 * Called prior to deleting the entire column family. Called as part of 322 * delete column RPC call. 323 * @param ctx the environment to interact with the framework and master 324 * @param tableName the name of the table 325 * @param c the column 326 */ 327 void preDeleteColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 328 final TableName tableName, final byte[] c) throws IOException; 329 330 /** 331 * Called after the column family has been deleted. Called as part of delete 332 * column RPC call. 333 * @param ctx the environment to interact with the framework and master 334 * @param tableName the name of the table 335 * @param c the column 336 */ 337 void postDeleteColumn(final ObserverContext<MasterCoprocessorEnvironment> ctx, 338 final TableName tableName, final byte[] c) throws IOException; 339 340 /** 341 * Called prior to deleting the entire column family. Called as part of 342 * delete column handler. 343 * @param ctx the environment to interact with the framework and master 344 * @param tableName the name of the table 345 * @param c the column 346 */ 347 void preDeleteColumnHandler( 348 final ObserverContext<MasterCoprocessorEnvironment> ctx, 349 final TableName tableName, final byte[] c) throws IOException; 350 351 /** 352 * Called after the column family has been deleted. Called as part of 353 * delete column handler. 354 * @param ctx the environment to interact with the framework and master 355 * @param tableName the name of the table 356 * @param c the column 357 */ 358 void postDeleteColumnHandler( 359 final ObserverContext<MasterCoprocessorEnvironment> ctx, 360 final TableName tableName, final byte[] c) throws IOException; 361 362 /** 363 * Called prior to enabling a table. Called as part of enable table RPC call. 364 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 365 * @param ctx the environment to interact with the framework and master 366 * @param tableName the name of the table 367 */ 368 void preEnableTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 369 final TableName tableName) throws IOException; 370 371 /** 372 * Called after the enableTable operation has been requested. Called as part 373 * of enable table RPC call. 374 * @param ctx the environment to interact with the framework and master 375 * @param tableName the name of the table 376 */ 377 void postEnableTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 378 final TableName tableName) throws IOException; 379 380 /** 381 * Called prior to enabling a table. Called as part of enable table handler 382 * and it is async to the enable table RPC call. 383 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 384 * @param ctx the environment to interact with the framework and master 385 * @param tableName the name of the table 386 */ 387 void preEnableTableHandler( 388 final ObserverContext<MasterCoprocessorEnvironment> ctx, 389 final TableName tableName) throws IOException; 390 391 /** 392 * Called after the enableTable operation has been requested. Called as part 393 * of enable table handler and it is async to the enable table RPC call. 394 * @param ctx the environment to interact with the framework and master 395 * @param tableName the name of the table 396 */ 397 void postEnableTableHandler( 398 final ObserverContext<MasterCoprocessorEnvironment> ctx, 399 final TableName tableName) throws IOException; 400 401 /** 402 * Called prior to disabling a table. Called as part of disable table RPC 403 * call. 404 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 405 * @param ctx the environment to interact with the framework and master 406 * @param tableName the name of the table 407 */ 408 void preDisableTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 409 final TableName tableName) throws IOException; 410 411 /** 412 * Called after the disableTable operation has been requested. Called as part 413 * of disable table RPC call. 414 * @param ctx the environment to interact with the framework and master 415 * @param tableName the name of the table 416 */ 417 void postDisableTable(final ObserverContext<MasterCoprocessorEnvironment> ctx, 418 final TableName tableName) throws IOException; 419 420 /** 421 * Called prior to disabling a table. Called as part of disable table handler 422 * and it is asyn to the disable table RPC call. 423 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 424 * @param ctx the environment to interact with the framework and master 425 * @param tableName the name of the table 426 */ 427 void preDisableTableHandler( 428 final ObserverContext<MasterCoprocessorEnvironment> ctx, 429 final TableName tableName) throws IOException; 430 431 /** 432 * Called after the disableTable operation has been requested. Called as part 433 * of disable table handler and it is asyn to the disable table RPC call. 434 * @param ctx the environment to interact with the framework and master 435 * @param tableName the name of the table 436 */ 437 void postDisableTableHandler( 438 final ObserverContext<MasterCoprocessorEnvironment> ctx, 439 final TableName tableName) throws IOException; 440 441 /** 442 * Called prior to moving a given region from one region server to another. 443 * @param ctx the environment to interact with the framework and master 444 * @param region the HRegionInfo 445 * @param srcServer the source ServerName 446 * @param destServer the destination ServerName 447 */ 448 void preMove(final ObserverContext<MasterCoprocessorEnvironment> ctx, 449 final HRegionInfo region, final ServerName srcServer, 450 final ServerName destServer) 451 throws IOException; 452 453 /** 454 * Called after the region move has been requested. 455 * @param ctx the environment to interact with the framework and master 456 * @param region the HRegionInfo 457 * @param srcServer the source ServerName 458 * @param destServer the destination ServerName 459 */ 460 void postMove(final ObserverContext<MasterCoprocessorEnvironment> ctx, 461 final HRegionInfo region, final ServerName srcServer, 462 final ServerName destServer) 463 throws IOException; 464 465 /** 466 * Called before a abortProcedure request has been processed. 467 * @param ctx the environment to interact with the framework and master 468 * @throws IOException 469 */ 470 public void preAbortProcedure( 471 ObserverContext<MasterCoprocessorEnvironment> ctx, 472 final ProcedureExecutor<MasterProcedureEnv> procEnv, 473 final long procId) throws IOException; 474 475 /** 476 * Called after a abortProcedure request has been processed. 477 * @param ctx the environment to interact with the framework and master 478 */ 479 public void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx) 480 throws IOException; 481 482 /** 483 * Called before a listProcedures request has been processed. 484 * @param ctx the environment to interact with the framework and master 485 * @throws IOException 486 */ 487 void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx) 488 throws IOException; 489 490 /** 491 * Called after a listProcedures request has been processed. 492 * @param ctx the environment to interact with the framework and master 493 * @param procInfoList the list of procedures about to be returned 494 */ 495 void postListProcedures( 496 ObserverContext<MasterCoprocessorEnvironment> ctx, 497 List<ProcedureInfo> procInfoList) throws IOException; 498 499 /** 500 * Called prior to assigning a specific region. 501 * @param ctx the environment to interact with the framework and master 502 * @param regionInfo the regionInfo of the region 503 */ 504 void preAssign(final ObserverContext<MasterCoprocessorEnvironment> ctx, 505 final HRegionInfo regionInfo) throws IOException; 506 507 /** 508 * Called after the region assignment has been requested. 509 * @param ctx the environment to interact with the framework and master 510 * @param regionInfo the regionInfo of the region 511 */ 512 void postAssign(final ObserverContext<MasterCoprocessorEnvironment> ctx, 513 final HRegionInfo regionInfo) throws IOException; 514 515 /** 516 * Called prior to unassigning a given region. 517 * @param ctx the environment to interact with the framework and master 518 * @param regionInfo 519 * @param force whether to force unassignment or not 520 */ 521 void preUnassign(final ObserverContext<MasterCoprocessorEnvironment> ctx, 522 final HRegionInfo regionInfo, final boolean force) throws IOException; 523 524 /** 525 * Called after the region unassignment has been requested. 526 * @param ctx the environment to interact with the framework and master 527 * @param regionInfo 528 * @param force whether to force unassignment or not 529 */ 530 void postUnassign(final ObserverContext<MasterCoprocessorEnvironment> ctx, 531 final HRegionInfo regionInfo, final boolean force) throws IOException; 532 533 /** 534 * Called prior to marking a given region as offline. <code>ctx.bypass()</code> will not have any 535 * impact on this hook. 536 * @param ctx the environment to interact with the framework and master 537 * @param regionInfo 538 */ 539 void preRegionOffline(final ObserverContext<MasterCoprocessorEnvironment> ctx, 540 final HRegionInfo regionInfo) throws IOException; 541 542 /** 543 * Called after the region has been marked offline. 544 * @param ctx the environment to interact with the framework and master 545 * @param regionInfo 546 */ 547 void postRegionOffline(final ObserverContext<MasterCoprocessorEnvironment> ctx, 548 final HRegionInfo regionInfo) throws IOException; 549 550 /** 551 * Called prior to requesting rebalancing of the cluster regions, though after 552 * the initial checks for regions in transition and the balance switch flag. 553 * @param ctx the environment to interact with the framework and master 554 */ 555 void preBalance(final ObserverContext<MasterCoprocessorEnvironment> ctx) 556 throws IOException; 557 558 /** 559 * Called after the balancing plan has been submitted. 560 * @param ctx the environment to interact with the framework and master 561 * @param plans the RegionPlans which master has executed. RegionPlan serves as hint 562 * as for the final destination for the underlying region but may not represent the 563 * final state of assignment 564 */ 565 void postBalance(final ObserverContext<MasterCoprocessorEnvironment> ctx, List<RegionPlan> plans) 566 throws IOException; 567 568 /** 569 * Called prior to modifying the flag used to enable/disable region balancing. 570 * @param ctx the coprocessor instance's environment 571 * @param newValue the new flag value submitted in the call 572 */ 573 boolean preBalanceSwitch(final ObserverContext<MasterCoprocessorEnvironment> ctx, 574 final boolean newValue) throws IOException; 575 576 /** 577 * Called after the flag to enable/disable balancing has changed. 578 * @param ctx the coprocessor instance's environment 579 * @param oldValue the previously set balanceSwitch value 580 * @param newValue the newly set balanceSwitch value 581 */ 582 void postBalanceSwitch(final ObserverContext<MasterCoprocessorEnvironment> ctx, 583 final boolean oldValue, final boolean newValue) throws IOException; 584 585 /** 586 * Called prior to shutting down the full HBase cluster, including this 587 * {@link org.apache.hadoop.hbase.master.HMaster} process. 588 */ 589 void preShutdown(final ObserverContext<MasterCoprocessorEnvironment> ctx) 590 throws IOException; 591 592 593 /** 594 * Called immediately prior to stopping this 595 * {@link org.apache.hadoop.hbase.master.HMaster} process. 596 */ 597 void preStopMaster(final ObserverContext<MasterCoprocessorEnvironment> ctx) 598 throws IOException; 599 600 /** 601 * Called immediately after an active master instance has completed 602 * initialization. Will not be called on standby master instances unless 603 * they take over the active role. 604 */ 605 void postStartMaster(final ObserverContext<MasterCoprocessorEnvironment> ctx) 606 throws IOException; 607 608 /** 609 * Call before the master initialization is set to true. 610 * {@link org.apache.hadoop.hbase.master.HMaster} process. 611 */ 612 void preMasterInitialization(final ObserverContext<MasterCoprocessorEnvironment> ctx) 613 throws IOException; 614 615 /** 616 * Called before a new snapshot is taken. 617 * Called as part of snapshot RPC call. 618 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 619 * @param ctx the environment to interact with the framework and master 620 * @param snapshot the SnapshotDescriptor for the snapshot 621 * @param hTableDescriptor the hTableDescriptor of the table to snapshot 622 * @throws IOException 623 */ 624 void preSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 625 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 626 throws IOException; 627 628 /** 629 * Called after the snapshot operation has been requested. 630 * Called as part of snapshot RPC call. 631 * @param ctx the environment to interact with the framework and master 632 * @param snapshot the SnapshotDescriptor for the snapshot 633 * @param hTableDescriptor the hTableDescriptor of the table to snapshot 634 * @throws IOException 635 */ 636 void postSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 637 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 638 throws IOException; 639 640 /** 641 * Called before listSnapshots request has been processed. 642 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 643 * @param ctx the environment to interact with the framework and master 644 * @param snapshot the SnapshotDescriptor of the snapshot to list 645 * @throws IOException 646 */ 647 void preListSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 648 final SnapshotDescription snapshot) throws IOException; 649 650 /** 651 * Called after listSnapshots request has been processed. 652 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 653 * @param ctx the environment to interact with the framework and master 654 * @param snapshot the SnapshotDescriptor of the snapshot to list 655 * @throws IOException 656 */ 657 void postListSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 658 final SnapshotDescription snapshot) throws IOException; 659 660 /** 661 * Called before a snapshot is cloned. 662 * Called as part of restoreSnapshot RPC call. 663 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 664 * @param ctx the environment to interact with the framework and master 665 * @param snapshot the SnapshotDescriptor for the snapshot 666 * @param hTableDescriptor the hTableDescriptor of the table to create 667 * @throws IOException 668 */ 669 void preCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 670 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 671 throws IOException; 672 673 /** 674 * Called after a snapshot clone operation has been requested. 675 * Called as part of restoreSnapshot RPC call. 676 * @param ctx the environment to interact with the framework and master 677 * @param snapshot the SnapshotDescriptor for the snapshot 678 * @param hTableDescriptor the hTableDescriptor of the table to create 679 * @throws IOException 680 */ 681 void postCloneSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 682 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 683 throws IOException; 684 685 /** 686 * Called before a snapshot is restored. 687 * Called as part of restoreSnapshot RPC call. 688 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 689 * @param ctx the environment to interact with the framework and master 690 * @param snapshot the SnapshotDescriptor for the snapshot 691 * @param hTableDescriptor the hTableDescriptor of the table to restore 692 * @throws IOException 693 */ 694 void preRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 695 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 696 throws IOException; 697 698 /** 699 * Called after a snapshot restore operation has been requested. 700 * Called as part of restoreSnapshot RPC call. 701 * @param ctx the environment to interact with the framework and master 702 * @param snapshot the SnapshotDescriptor for the snapshot 703 * @param hTableDescriptor the hTableDescriptor of the table to restore 704 * @throws IOException 705 */ 706 void postRestoreSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 707 final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor) 708 throws IOException; 709 710 /** 711 * Called before a snapshot is deleted. 712 * Called as part of deleteSnapshot RPC call. 713 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 714 * @param ctx the environment to interact with the framework and master 715 * @param snapshot the SnapshotDescriptor of the snapshot to delete 716 * @throws IOException 717 */ 718 void preDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 719 final SnapshotDescription snapshot) throws IOException; 720 721 /** 722 * Called after the delete snapshot operation has been requested. 723 * Called as part of deleteSnapshot RPC call. 724 * @param ctx the environment to interact with the framework and master 725 * @param snapshot the SnapshotDescriptor of the snapshot to delete 726 * @throws IOException 727 */ 728 void postDeleteSnapshot(final ObserverContext<MasterCoprocessorEnvironment> ctx, 729 final SnapshotDescription snapshot) throws IOException; 730 731 /** 732 * Called before a getTableDescriptors request has been processed. 733 * @param ctx the environment to interact with the framework and master 734 * @param tableNamesList the list of table names, or null if querying for all 735 * @param descriptors an empty list, can be filled with what to return if bypassing 736 * @throws IOException 737 * @deprecated Use preGetTableDescriptors with regex instead. 738 */ 739 @Deprecated 740 void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, 741 List<TableName> tableNamesList, List<HTableDescriptor> descriptors) throws IOException; 742 743 /** 744 * Called after a getTableDescriptors request has been processed. 745 * @param ctx the environment to interact with the framework and master 746 * @param descriptors the list of descriptors about to be returned 747 * @throws IOException 748 * @deprecated Use postGetTableDescriptors with regex instead. 749 */ 750 @Deprecated 751 void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, 752 List<HTableDescriptor> descriptors) throws IOException; 753 754 /** 755 * Called before a getTableDescriptors request has been processed. 756 * @param ctx the environment to interact with the framework and master 757 * @param tableNamesList the list of table names, or null if querying for all 758 * @param descriptors an empty list, can be filled with what to return if bypassing 759 * @param regex regular expression used for filtering the table names 760 * @throws IOException 761 */ 762 void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, 763 List<TableName> tableNamesList, List<HTableDescriptor> descriptors, 764 String regex) throws IOException; 765 766 /** 767 * Called after a getTableDescriptors request has been processed. 768 * @param ctx the environment to interact with the framework and master 769 * @param tableNamesList the list of table names, or null if querying for all 770 * @param descriptors the list of descriptors about to be returned 771 * @param regex regular expression used for filtering the table names 772 * @throws IOException 773 */ 774 void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, 775 List<TableName> tableNamesList, List<HTableDescriptor> descriptors, 776 String regex) throws IOException; 777 778 /** 779 * Called before a getTableNames request has been processed. 780 * @param ctx the environment to interact with the framework and master 781 * @param descriptors an empty list, can be filled with what to return if bypassing 782 * @param regex regular expression used for filtering the table names 783 * @throws IOException 784 */ 785 void preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, 786 List<HTableDescriptor> descriptors, String regex) throws IOException; 787 788 /** 789 * Called after a getTableNames request has been processed. 790 * @param ctx the environment to interact with the framework and master 791 * @param descriptors the list of descriptors about to be returned 792 * @param regex regular expression used for filtering the table names 793 * @throws IOException 794 */ 795 void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx, 796 List<HTableDescriptor> descriptors, String regex) throws IOException; 797 798 /** 799 * Called before a new namespace is created by 800 * {@link org.apache.hadoop.hbase.master.HMaster}. 801 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 802 * @param ctx the environment to interact with the framework and master 803 * @param ns the NamespaceDescriptor for the table 804 * @throws IOException 805 */ 806 void preCreateNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 807 NamespaceDescriptor ns) throws IOException; 808 /** 809 * Called after the createNamespace operation has been requested. 810 * @param ctx the environment to interact with the framework and master 811 * @param ns the NamespaceDescriptor for the table 812 * @throws IOException 813 */ 814 void postCreateNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 815 NamespaceDescriptor ns) throws IOException; 816 817 /** 818 * Called before {@link org.apache.hadoop.hbase.master.HMaster} deletes a 819 * namespace 820 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 821 * @param ctx the environment to interact with the framework and master 822 * @param namespace the name of the namespace 823 */ 824 void preDeleteNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 825 String namespace) throws IOException; 826 827 /** 828 * Called after the deleteNamespace operation has been requested. 829 * @param ctx the environment to interact with the framework and master 830 * @param namespace the name of the namespace 831 */ 832 void postDeleteNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 833 String namespace) throws IOException; 834 835 /** 836 * Called prior to modifying a namespace's properties. 837 * It can't bypass the default action, e.g., ctx.bypass() won't have effect. 838 * @param ctx the environment to interact with the framework and master 839 * @param ns the NamespaceDescriptor 840 */ 841 void preModifyNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 842 NamespaceDescriptor ns) throws IOException; 843 844 /** 845 * Called after the modifyNamespace operation has been requested. 846 * @param ctx the environment to interact with the framework and master 847 * @param ns the NamespaceDescriptor 848 */ 849 void postModifyNamespace(final ObserverContext<MasterCoprocessorEnvironment> ctx, 850 NamespaceDescriptor ns) throws IOException; 851 852 /** 853 * Called before a getNamespaceDescriptor request has been processed. 854 * @param ctx the environment to interact with the framework and master 855 * @param namespace the name of the namespace 856 * @throws IOException 857 */ 858 void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, 859 String namespace) throws IOException; 860 861 /** 862 * Called after a getNamespaceDescriptor request has been processed. 863 * @param ctx the environment to interact with the framework and master 864 * @param ns the NamespaceDescriptor 865 * @throws IOException 866 */ 867 void postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, 868 NamespaceDescriptor ns) throws IOException; 869 870 /** 871 * Called before a listNamespaceDescriptors request has been processed. 872 * @param ctx the environment to interact with the framework and master 873 * @param descriptors an empty list, can be filled with what to return if bypassing 874 * @throws IOException 875 */ 876 void preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, 877 List<NamespaceDescriptor> descriptors) throws IOException; 878 879 /** 880 * Called after a listNamespaceDescriptors request has been processed. 881 * @param ctx the environment to interact with the framework and master 882 * @param descriptors the list of descriptors about to be returned 883 * @throws IOException 884 */ 885 void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx, 886 List<NamespaceDescriptor> descriptors) throws IOException; 887 888 889 /** 890 * Called before the table memstore is flushed to disk. 891 * @param ctx the environment to interact with the framework and master 892 * @param tableName the name of the table 893 * @throws IOException 894 */ 895 void preTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, 896 final TableName tableName) throws IOException; 897 898 /** 899 * Called after the table memstore is flushed to disk. 900 * @param ctx the environment to interact with the framework and master 901 * @param tableName the name of the table 902 * @throws IOException 903 */ 904 void postTableFlush(final ObserverContext<MasterCoprocessorEnvironment> ctx, 905 final TableName tableName) throws IOException; 906 907 /** 908 * Called before the quota for the user is stored. 909 * @param ctx the environment to interact with the framework and master 910 * @param userName the name of user 911 * @param quotas the quota settings 912 * @throws IOException 913 */ 914 void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, 915 final String userName, final Quotas quotas) throws IOException; 916 917 /** 918 * Called after the quota for the user is stored. 919 * @param ctx the environment to interact with the framework and master 920 * @param userName the name of user 921 * @param quotas the quota settings 922 * @throws IOException 923 */ 924 void postSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, 925 final String userName, final Quotas quotas) throws IOException; 926 927 /** 928 * Called before the quota for the user on the specified table is stored. 929 * @param ctx the environment to interact with the framework and master 930 * @param userName the name of user 931 * @param tableName the name of the table 932 * @param quotas the quota settings 933 * @throws IOException 934 */ 935 void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, 936 final String userName, final TableName tableName, final Quotas quotas) throws IOException; 937 938 /** 939 * Called after the quota for the user on the specified table is stored. 940 * @param ctx the environment to interact with the framework and master 941 * @param userName the name of user 942 * @param tableName the name of the table 943 * @param quotas the quota settings 944 * @throws IOException 945 */ 946 void postSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, 947 final String userName, final TableName tableName, final Quotas quotas) throws IOException; 948 949 /** 950 * Called before the quota for the user on the specified namespace is stored. 951 * @param ctx the environment to interact with the framework and master 952 * @param userName the name of user 953 * @param namespace the name of the namespace 954 * @param quotas the quota settings 955 * @throws IOException 956 */ 957 void preSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, 958 final String userName, final String namespace, final Quotas quotas) throws IOException; 959 960 /** 961 * Called after the quota for the user on the specified namespace is stored. 962 * @param ctx the environment to interact with the framework and master 963 * @param userName the name of user 964 * @param namespace the name of the namespace 965 * @param quotas the quota settings 966 * @throws IOException 967 */ 968 void postSetUserQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, 969 final String userName, final String namespace, final Quotas quotas) throws IOException; 970 971 /** 972 * Called before the quota for the table is stored. 973 * @param ctx the environment to interact with the framework and master 974 * @param tableName the name of the table 975 * @param quotas the quota settings 976 * @throws IOException 977 */ 978 void preSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, 979 final TableName tableName, final Quotas quotas) throws IOException; 980 981 /** 982 * Called after the quota for the table is stored. 983 * @param ctx the environment to interact with the framework and master 984 * @param tableName the name of the table 985 * @param quotas the quota settings 986 * @throws IOException 987 */ 988 void postSetTableQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, 989 final TableName tableName, final Quotas quotas) throws IOException; 990 991 /** 992 * Called before the quota for the namespace is stored. 993 * @param ctx the environment to interact with the framework and master 994 * @param namespace the name of the namespace 995 * @param quotas the quota settings 996 * @throws IOException 997 */ 998 void preSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, 999 final String namespace, final Quotas quotas) throws IOException; 1000 1001 /** 1002 * Called after the quota for the namespace is stored. 1003 * @param ctx the environment to interact with the framework and master 1004 * @param namespace the name of the namespace 1005 * @param quotas the quota settings 1006 * @throws IOException 1007 */ 1008 void postSetNamespaceQuota(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1009 final String namespace, final Quotas quotas) throws IOException; 1010 1011 /** 1012 * Called before servers are moved to target region server group 1013 * @param ctx the environment to interact with the framework and master 1014 * @param servers set of servers to move 1015 * @param targetGroup destination group 1016 * @throws IOException on failure 1017 */ 1018 void preMoveServers(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1019 Set<HostAndPort> servers, String targetGroup) throws IOException; 1020 1021 /** 1022 * Called after servers are moved to target region server group 1023 * @param ctx the environment to interact with the framework and master 1024 * @param servers set of servers to move 1025 * @param targetGroup name of group 1026 * @throws IOException on failure 1027 */ 1028 void postMoveServers(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1029 Set<HostAndPort> servers, String targetGroup) throws IOException; 1030 1031 /** 1032 * Called before tables are moved to target region server group 1033 * @param ctx the environment to interact with the framework and master 1034 * @param tables set of tables to move 1035 * @param targetGroup name of group 1036 * @throws IOException on failure 1037 */ 1038 void preMoveTables(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1039 Set<TableName> tables, String targetGroup) throws IOException; 1040 1041 /** 1042 * Called after servers are moved to target region server group 1043 * @param ctx the environment to interact with the framework and master 1044 * @param tables set of tables to move 1045 * @param targetGroup name of group 1046 * @throws IOException on failure 1047 */ 1048 void postMoveTables(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1049 Set<TableName> tables, String targetGroup) throws IOException; 1050 1051 /** 1052 * Called before a new region server group is added 1053 * @param ctx the environment to interact with the framework and master 1054 * @param name group name 1055 * @throws IOException on failure 1056 */ 1057 void preAddRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1058 String name) throws IOException; 1059 1060 /** 1061 * Called after a new region server group is added 1062 * @param ctx the environment to interact with the framework and master 1063 * @param name group name 1064 * @throws IOException on failure 1065 */ 1066 void postAddRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1067 String name) throws IOException; 1068 1069 /** 1070 * Called before a region server group is removed 1071 * @param ctx the environment to interact with the framework and master 1072 * @param name group name 1073 * @throws IOException on failure 1074 */ 1075 void preRemoveRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1076 String name) throws IOException; 1077 1078 /** 1079 * Called after a region server group is removed 1080 * @param ctx the environment to interact with the framework and master 1081 * @param name group name 1082 * @throws IOException on failure 1083 */ 1084 void postRemoveRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1085 String name) throws IOException; 1086 1087 /** 1088 * Called before a region server group is removed 1089 * @param ctx the environment to interact with the framework and master 1090 * @param groupName group name 1091 * @throws IOException on failure 1092 */ 1093 void preBalanceRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1094 String groupName) throws IOException; 1095 1096 /** 1097 * Called after a region server group is removed 1098 * @param ctx the environment to interact with the framework and master 1099 * @param groupName group name 1100 * @throws IOException on failure 1101 */ 1102 void postBalanceRSGroup(final ObserverContext<MasterCoprocessorEnvironment> ctx, 1103 String groupName, boolean balancerRan) throws IOException; 1104 1105 }