View Javadoc

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