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