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