View Javadoc

1   /**
2    * Copyright The Apache Software Foundation
3    *
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *     http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing, software
15   * distributed under the License is distributed on an "AS IS" BASIS,
16   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17   * See the License for the specific language governing permissions and
18   * limitations under the License.
19   */
20  
21  package org.apache.hadoop.hbase.rsgroup;
22  
23  import com.google.common.collect.Sets;
24  import com.google.common.net.HostAndPort;
25  import com.google.protobuf.RpcCallback;
26  import com.google.protobuf.RpcController;
27  import com.google.protobuf.Service;
28  
29  import java.io.IOException;
30  import java.util.HashSet;
31  import java.util.List;
32  import java.util.Set;
33  
34  import org.apache.commons.logging.Log;
35  import org.apache.commons.logging.LogFactory;
36  import org.apache.hadoop.hbase.Coprocessor;
37  import org.apache.hadoop.hbase.CoprocessorEnvironment;
38  import org.apache.hadoop.hbase.HColumnDescriptor;
39  import org.apache.hadoop.hbase.HConstants;
40  import org.apache.hadoop.hbase.HRegionInfo;
41  import org.apache.hadoop.hbase.HTableDescriptor;
42  import org.apache.hadoop.hbase.NamespaceDescriptor;
43  import org.apache.hadoop.hbase.ProcedureInfo;
44  import org.apache.hadoop.hbase.ServerName;
45  import org.apache.hadoop.hbase.TableName;
46  import org.apache.hadoop.hbase.constraint.ConstraintException;
47  import org.apache.hadoop.hbase.coprocessor.CoprocessorService;
48  import org.apache.hadoop.hbase.coprocessor.MasterCoprocessorEnvironment;
49  import org.apache.hadoop.hbase.coprocessor.MasterObserver;
50  import org.apache.hadoop.hbase.coprocessor.ObserverContext;
51  import org.apache.hadoop.hbase.master.MasterServices;
52  import org.apache.hadoop.hbase.master.RegionPlan;
53  import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv;
54  import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
55  import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
56  import org.apache.hadoop.hbase.protobuf.ResponseConverter;
57  import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos;
58  import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription;
59  import org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas;
60  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos;
61  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.AddRSGroupRequest;
62  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.AddRSGroupResponse;
63  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.BalanceRSGroupRequest;
64  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.BalanceRSGroupResponse;
65  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoOfServerRequest;
66  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoOfServerResponse;
67  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoOfTableRequest;
68  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoOfTableResponse;
69  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoRequest;
70  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoResponse;
71  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.ListRSGroupInfosRequest;
72  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.ListRSGroupInfosResponse;
73  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.MoveServersRequest;
74  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.MoveServersResponse;
75  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.MoveTablesRequest;
76  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.MoveTablesResponse;
77  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RSGroupAdminService;
78  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RemoveRSGroupRequest;
79  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RemoveRSGroupResponse;
80  
81  
82  public class RSGroupAdminEndpoint extends RSGroupAdminService
83      implements CoprocessorService, Coprocessor, MasterObserver {
84  
85    private static final Log LOG = LogFactory.getLog(RSGroupAdminEndpoint.class);
86    private MasterServices master = null;
87  
88    private static RSGroupInfoManagerImpl groupInfoManager;
89    private RSGroupAdminServer groupAdminServer;
90  
91    @Override
92    public void start(CoprocessorEnvironment env) throws IOException {
93      MasterCoprocessorEnvironment menv = (MasterCoprocessorEnvironment)env;
94      master = menv.getMasterServices();
95      groupInfoManager = new RSGroupInfoManagerImpl(master);
96      groupAdminServer = new RSGroupAdminServer(master, groupInfoManager);
97      Class clazz =
98          master.getConfiguration().getClass(HConstants.HBASE_MASTER_LOADBALANCER_CLASS, null);
99      if (!RSGroupableBalancer.class.isAssignableFrom(clazz)) {
100       throw new IOException("Configured balancer is not a GroupableBalancer");
101     }
102   }
103 
104   @Override
105   public void stop(CoprocessorEnvironment env) throws IOException {
106   }
107 
108   @Override
109   public Service getService() {
110     return this;
111   }
112 
113   public RSGroupInfoManager getGroupInfoManager() {
114     return groupInfoManager;
115   }
116 
117   @Override
118   public void getRSGroupInfo(RpcController controller,
119                            GetRSGroupInfoRequest request,
120                            RpcCallback<GetRSGroupInfoResponse> done) {
121     GetRSGroupInfoResponse response = null;
122     try {
123       GetRSGroupInfoResponse.Builder builder =
124           GetRSGroupInfoResponse.newBuilder();
125       RSGroupInfo RSGroupInfo = groupAdminServer.getRSGroupInfo(request.getRSGroupName());
126       if(RSGroupInfo != null) {
127         builder.setRSGroupInfo(ProtobufUtil.toProtoGroupInfo(RSGroupInfo));
128       }
129       response = builder.build();
130     } catch (IOException e) {
131       ResponseConverter.setControllerException(controller, e);
132     }
133     done.run(response);
134   }
135 
136   @Override
137   public void getRSGroupInfoOfTable(RpcController controller,
138                                   GetRSGroupInfoOfTableRequest request,
139                                   RpcCallback<GetRSGroupInfoOfTableResponse> done) {
140     GetRSGroupInfoOfTableResponse response = null;
141     try {
142       GetRSGroupInfoOfTableResponse.Builder builder =
143           GetRSGroupInfoOfTableResponse.newBuilder();
144       TableName tableName = ProtobufUtil.toTableName(request.getTableName());
145       RSGroupInfo RSGroupInfo = groupAdminServer.getRSGroupInfoOfTable(tableName);
146       if (RSGroupInfo == null) {
147         response = builder.build();
148       } else {
149         response = builder.setRSGroupInfo(ProtobufUtil.toProtoGroupInfo(RSGroupInfo)).build();
150       }
151     } catch (IOException e) {
152       ResponseConverter.setControllerException(controller, e);
153     }
154     done.run(response);
155   }
156 
157   @Override
158   public void moveServers(RpcController controller,
159                           MoveServersRequest request,
160                           RpcCallback<MoveServersResponse> done) {
161     RSGroupAdminProtos.MoveServersResponse response = null;
162     try {
163       RSGroupAdminProtos.MoveServersResponse.Builder builder =
164           RSGroupAdminProtos.MoveServersResponse.newBuilder();
165       Set<HostAndPort> hostPorts = Sets.newHashSet();
166       for(HBaseProtos.ServerName el: request.getServersList()) {
167         hostPorts.add(HostAndPort.fromParts(el.getHostName(), el.getPort()));
168       }
169       groupAdminServer.moveServers(hostPorts, request.getTargetGroup());
170       response = builder.build();
171     } catch (IOException e) {
172       ResponseConverter.setControllerException(controller, e);
173     }
174     done.run(response);
175   }
176 
177   @Override
178   public void moveTables(RpcController controller,
179                          MoveTablesRequest request,
180                          RpcCallback<MoveTablesResponse> done) {
181     MoveTablesResponse response = null;
182     try {
183       MoveTablesResponse.Builder builder =
184           MoveTablesResponse.newBuilder();
185       Set<TableName> tables = new HashSet<TableName>(request.getTableNameList().size());
186       for(HBaseProtos.TableName tableName: request.getTableNameList()) {
187         tables.add(ProtobufUtil.toTableName(tableName));
188       }
189       groupAdminServer.moveTables(tables, request.getTargetGroup());
190       response = builder.build();
191     } catch (IOException e) {
192       ResponseConverter.setControllerException(controller, e);
193     }
194     done.run(response);
195   }
196 
197   @Override
198   public void addRSGroup(RpcController controller,
199                        AddRSGroupRequest request,
200                        RpcCallback<AddRSGroupResponse> done) {
201     AddRSGroupResponse response = null;
202     try {
203       AddRSGroupResponse.Builder builder =
204           AddRSGroupResponse.newBuilder();
205       groupAdminServer.addRSGroup(request.getRSGroupName());
206       response = builder.build();
207     } catch (IOException e) {
208       ResponseConverter.setControllerException(controller, e);
209     }
210     done.run(response);
211   }
212 
213   @Override
214   public void removeRSGroup(RpcController controller,
215                           RemoveRSGroupRequest request,
216                           RpcCallback<RemoveRSGroupResponse> done) {
217     RemoveRSGroupResponse response = null;
218     try {
219       RemoveRSGroupResponse.Builder builder =
220           RemoveRSGroupResponse.newBuilder();
221       groupAdminServer.removeRSGroup(request.getRSGroupName());
222       response = builder.build();
223     } catch (IOException e) {
224       ResponseConverter.setControllerException(controller, e);
225     }
226     done.run(response);
227   }
228 
229   @Override
230   public void balanceRSGroup(RpcController controller,
231                            BalanceRSGroupRequest request,
232                            RpcCallback<BalanceRSGroupResponse> done) {
233     BalanceRSGroupResponse.Builder builder = BalanceRSGroupResponse.newBuilder();
234     try {
235       builder.setBalanceRan(groupAdminServer.balanceRSGroup(request.getRSGroupName()));
236     } catch (IOException e) {
237       ResponseConverter.setControllerException(controller, e);
238       builder.setBalanceRan(false);
239     }
240     done.run(builder.build());
241   }
242 
243   @Override
244   public void listRSGroupInfos(RpcController controller,
245                              ListRSGroupInfosRequest request,
246                              RpcCallback<ListRSGroupInfosResponse> done) {
247     ListRSGroupInfosResponse response = null;
248     try {
249       ListRSGroupInfosResponse.Builder builder =
250           ListRSGroupInfosResponse.newBuilder();
251       for(RSGroupInfo RSGroupInfo : groupAdminServer.listRSGroups()) {
252         builder.addRSGroupInfo(ProtobufUtil.toProtoGroupInfo(RSGroupInfo));
253       }
254       response = builder.build();
255     } catch (IOException e) {
256       ResponseConverter.setControllerException(controller, e);
257     }
258     done.run(response);
259   }
260 
261   @Override
262   public void getRSGroupInfoOfServer(RpcController controller,
263                                    GetRSGroupInfoOfServerRequest request,
264                                    RpcCallback<GetRSGroupInfoOfServerResponse> done) {
265     GetRSGroupInfoOfServerResponse.Builder builder = GetRSGroupInfoOfServerResponse.newBuilder();
266     try {
267       HostAndPort hp =
268           HostAndPort.fromParts(request.getServer().getHostName(), request.getServer().getPort());
269       RSGroupInfo RSGroupInfo = groupAdminServer.getRSGroupOfServer(hp);
270       if (RSGroupInfo != null) {
271         builder.setRSGroupInfo(ProtobufUtil.toProtoGroupInfo(RSGroupInfo));
272       }
273     } catch (IOException e) {
274       ResponseConverter.setControllerException(controller, e);
275     }
276     done.run(builder.build());
277   }
278 
279   @Override
280   public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
281       HTableDescriptor desc, HRegionInfo[] regions) throws IOException {
282     groupAdminServer.prepareRSGroupForTable(desc);
283   }
284 
285   @Override
286   public void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
287                               TableName tableName) throws IOException {
288     groupAdminServer.cleanupRSGroupForTable(tableName);
289   }
290 
291   @Override
292   public void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
293                                  NamespaceDescriptor ns) throws IOException {
294     String group = ns.getConfigurationValue(RSGroupInfo.NAMESPACEDESC_PROP_GROUP);
295     if(group != null && groupAdminServer.getRSGroupInfo(group) == null) {
296       throw new ConstraintException("Region server group "+group+" does not exit");
297     }
298   }
299 
300   @Override
301   public void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
302                                  NamespaceDescriptor ns) throws IOException {
303     preCreateNamespace(ctx, ns);
304   }
305 
306   @Override
307   public void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
308                               HTableDescriptor desc,
309                               HRegionInfo[] regions) throws IOException {
310   }
311 
312   @Override
313   public void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
314                                     HTableDescriptor desc,
315                                     HRegionInfo[] regions) throws IOException {
316   }
317 
318   @Override
319   public void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
320                                      HTableDescriptor desc,
321                                      HRegionInfo[] regions) throws IOException {
322   }
323 
324   @Override
325   public void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
326                              TableName tableName) throws IOException {
327   }
328 
329   @Override
330   public void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
331                                     TableName tableName) throws IOException {
332   }
333 
334   @Override
335   public void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
336                                      TableName tableName) throws IOException {
337   }
338 
339   @Override
340   public void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
341                                TableName tableName) throws IOException {
342   }
343 
344   @Override
345   public void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
346                                 TableName tableName) throws IOException {
347   }
348 
349   @Override
350   public void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
351                                       TableName tableName) throws IOException {
352   }
353 
354   @Override
355   public void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
356                                        TableName tableName) throws IOException {
357   }
358 
359   @Override
360   public void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
361                              TableName tableName,
362                              HTableDescriptor htd) throws IOException {
363   }
364 
365   @Override
366   public void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
367                               TableName tableName,
368                               HTableDescriptor htd) throws IOException {
369   }
370 
371   @Override
372   public void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
373                                     TableName tableName,
374                                     HTableDescriptor htd) throws IOException {
375   }
376 
377   @Override
378   public void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
379                                      TableName tableName,
380                                      HTableDescriptor htd) throws IOException {
381   }
382 
383   @Override
384   public void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
385                            TableName tableName,
386                            HColumnDescriptor columnFamily) throws IOException {
387   }
388 
389   @Override
390   public void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
391                             TableName tableName,
392                             HColumnDescriptor columnFamily) throws IOException {
393   }
394 
395   @Override
396   public void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
397                                   TableName tableName,
398                                   HColumnDescriptor columnFamily) throws IOException {
399   }
400 
401   @Override
402   public void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
403                                    TableName tableName,
404                                    HColumnDescriptor columnFamily) throws IOException {
405   }
406 
407   @Override
408   public void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
409                               TableName tableName,
410                               HColumnDescriptor columnFamily) throws IOException {
411   }
412 
413   @Override
414   public void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
415                                TableName tableName,
416                                HColumnDescriptor columnFamily) throws IOException {
417   }
418 
419   @Override
420   public void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
421       tableName, HColumnDescriptor columnFamily) throws IOException {
422 
423   }
424 
425   @Override
426   public void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
427                                       TableName tableName, HColumnDescriptor columnFamily) throws
428       IOException {
429 
430   }
431 
432   @Override
433   public void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
434       tableName, byte[] columnFamily) throws IOException {
435 
436   }
437 
438   @Override
439   public void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
440       tableName, byte[] columnFamily) throws IOException {
441 
442   }
443 
444   @Override
445   public void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
446       tableName, byte[] columnFamily) throws IOException {
447 
448   }
449 
450   @Override
451   public void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
452                                       TableName tableName, byte[] columnFamily) throws IOException {
453 
454   }
455 
456   @Override
457   public void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
458       tableName) throws IOException {
459 
460   }
461 
462   @Override
463   public void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
464       tableName) throws IOException {
465 
466   }
467 
468   @Override
469   public void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
470       tableName) throws IOException {
471 
472   }
473 
474   @Override
475   public void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
476       tableName) throws IOException {
477 
478   }
479 
480   @Override
481   public void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
482       tableName) throws IOException {
483 
484   }
485 
486   @Override
487   public void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
488       tableName) throws IOException {
489 
490   }
491 
492   @Override
493   public void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
494       tableName) throws IOException {
495 
496   }
497 
498   @Override
499   public void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
500                                       TableName tableName) throws IOException {
501 
502   }
503 
504   @Override
505   public void preMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region,
506                       ServerName srcServer, ServerName destServer) throws IOException {
507 
508   }
509 
510   @Override
511   public void postMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region,
512                        ServerName srcServer, ServerName destServer) throws IOException {
513 
514   }
515 
516   @Override
517   public void preAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo
518       regionInfo) throws IOException {
519 
520   }
521 
522   @Override
523   public void postAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo
524       regionInfo) throws IOException {
525 
526   }
527 
528   @Override
529   public void preUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo
530       regionInfo, boolean force) throws IOException {
531 
532   }
533 
534   @Override
535   public void postUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo
536       regionInfo, boolean force) throws IOException {
537 
538   }
539 
540   @Override
541   public void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo
542       regionInfo) throws IOException {
543 
544   }
545 
546   @Override
547   public void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo
548       regionInfo) throws IOException {
549 
550   }
551 
552   @Override
553   public void preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
554 
555   }
556 
557   @Override
558   public void postBalance(ObserverContext<MasterCoprocessorEnvironment> ctx, List<RegionPlan>
559       plans) throws IOException {
560 
561   }
562 
563   @Override
564   public boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean
565       newValue) throws IOException {
566     return newValue;
567   }
568 
569   @Override
570   public void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean
571       oldValue, boolean newValue) throws IOException {
572 
573   }
574 
575   @Override
576   public void preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
577 
578   }
579 
580   @Override
581   public void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
582 
583   }
584 
585   @Override
586   public void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx) throws
587       IOException {
588 
589   }
590 
591   @Override
592   public void preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx) throws
593       IOException {
594 
595   }
596 
597   @Override
598   public void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription
599       snapshot, HTableDescriptor hTableDescriptor) throws IOException {
600 
601   }
602 
603   @Override
604   public void postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription
605       snapshot, HTableDescriptor hTableDescriptor) throws IOException {
606 
607   }
608 
609   @Override
610   public void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
611                               SnapshotDescription snapshot) throws IOException {
612 
613   }
614 
615   @Override
616   public void postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
617                                SnapshotDescription snapshot) throws IOException {
618 
619   }
620 
621   @Override
622   public void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
623                                SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
624       throws IOException {
625 
626   }
627 
628   @Override
629   public void postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
630                                 SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
631       throws IOException {
632 
633   }
634 
635   @Override
636   public void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
637                                  SnapshotDescription snapshot, HTableDescriptor hTableDescriptor)
638       throws IOException {
639 
640   }
641 
642   @Override
643   public void postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
644                                   SnapshotDescription snapshot, HTableDescriptor
645       hTableDescriptor) throws IOException {
646 
647   }
648 
649   @Override
650   public void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
651                                 SnapshotDescription snapshot) throws IOException {
652 
653   }
654 
655   @Override
656   public void postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
657                                  SnapshotDescription snapshot) throws IOException {
658 
659   }
660 
661   @Override
662   public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
663                                      List<TableName> tableNamesList, List<HTableDescriptor>
664       descriptors, String regex) throws IOException {
665 
666   }
667 
668   @Override
669   public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
670                                       List<TableName> tableNamesList, List<HTableDescriptor>
671       descriptors, String regex) throws IOException {
672 
673   }
674 
675   @Override
676   public void preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
677                                List<HTableDescriptor> descriptors, String regex) throws
678       IOException {
679 
680   }
681 
682   @Override
683   public void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
684                                 List<HTableDescriptor> descriptors, String regex) throws
685       IOException {
686 
687   }
688 
689   @Override
690   public void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
691                                   NamespaceDescriptor ns) throws IOException {
692 
693   }
694 
695   @Override
696   public void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String
697       namespace) throws IOException {
698 
699   }
700 
701   @Override
702   public void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx, String
703       namespace) throws IOException {
704 
705   }
706 
707   @Override
708   public void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
709                                   NamespaceDescriptor ns) throws IOException {
710 
711   }
712 
713   @Override
714   public void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx, String
715       namespace) throws IOException {
716 
717   }
718 
719   @Override
720   public void postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
721                                          NamespaceDescriptor ns) throws IOException {
722 
723   }
724 
725   @Override
726   public void preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
727                                           List<NamespaceDescriptor> descriptors) throws
728       IOException {
729 
730   }
731 
732   @Override
733   public void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
734                                            List<NamespaceDescriptor> descriptors) throws
735       IOException {
736 
737   }
738 
739   @Override
740   public void preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
741       tableName) throws IOException {
742 
743   }
744 
745   @Override
746   public void postTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
747       tableName) throws IOException {
748 
749   }
750 
751   @Override
752   public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
753                               Quotas quotas) throws IOException {
754 
755   }
756 
757   @Override
758   public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String
759       userName, Quotas quotas) throws IOException {
760 
761   }
762 
763   @Override
764   public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
765                               TableName tableName, Quotas quotas) throws IOException {
766 
767   }
768 
769   @Override
770   public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String
771       userName, TableName tableName, Quotas quotas) throws IOException {
772 
773   }
774 
775   @Override
776   public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
777                               String namespace, Quotas quotas) throws IOException {
778 
779   }
780 
781   @Override
782   public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String
783       userName, String namespace, Quotas quotas) throws IOException {
784 
785   }
786 
787   @Override
788   public void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
789       tableName, Quotas quotas) throws IOException {
790 
791   }
792 
793   @Override
794   public void postSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
795       tableName, Quotas quotas) throws IOException {
796 
797   }
798 
799   @Override
800   public void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String
801       namespace, Quotas quotas) throws IOException {
802 
803   }
804 
805   @Override
806   public void postSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String
807       namespace, Quotas quotas) throws IOException {
808   }
809 
810   @Override
811   public void preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<HostAndPort>
812       servers, String targetGroup) throws IOException {
813   }
814 
815   @Override
816   public void postMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<HostAndPort>
817       servers, String targetGroup) throws IOException {
818   }
819 
820   @Override
821   public void preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<TableName>
822       tables, String targetGroup) throws IOException {
823   }
824 
825   @Override
826   public void postMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
827       Set<TableName> tables, String targetGroup) throws IOException {
828   }
829 
830   @Override
831   public void preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)
832       throws IOException {
833   }
834 
835   @Override
836   public void postAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)
837       throws IOException {
838   }
839 
840   @Override
841   public void preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)
842       throws IOException {
843   }
844 
845   @Override
846   public void postRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String name)
847       throws IOException {
848   }
849 
850   @Override
851   public void preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx, String groupName)
852       throws IOException {
853   }
854 
855   @Override
856   public void postBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
857                                  String groupName, boolean balancerRan) throws IOException {
858   }
859 
860   @Override
861   public void preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx,
862       ProcedureExecutor<MasterProcedureEnv> procEnv, long procId) throws IOException {
863   }
864 
865   @Override
866   public void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)
867       throws IOException {
868   }
869 
870   @Override
871   public void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx)
872       throws IOException {
873   }
874 
875   @Override
876   public void postListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx,
877       List<ProcedureInfo> procInfoList) throws IOException {
878   }
879 
880   @Override
881   public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
882       List<TableName> tableNamesList, List<HTableDescriptor> descriptors) throws IOException {
883   }
884 
885   @Override
886   public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
887       List<HTableDescriptor> descriptors) throws IOException {
888   }
889 }