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 }