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  
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.ClusterStatus;
37  import org.apache.hadoop.hbase.Coprocessor;
38  import org.apache.hadoop.hbase.CoprocessorEnvironment;
39  import org.apache.hadoop.hbase.HColumnDescriptor;
40  import org.apache.hadoop.hbase.HConstants;
41  import org.apache.hadoop.hbase.HRegionInfo;
42  import org.apache.hadoop.hbase.HTableDescriptor;
43  import org.apache.hadoop.hbase.MasterNotRunningException;
44  import org.apache.hadoop.hbase.NamespaceDescriptor;
45  import org.apache.hadoop.hbase.ProcedureInfo;
46  import org.apache.hadoop.hbase.PleaseHoldException;
47  import org.apache.hadoop.hbase.ServerName;
48  import org.apache.hadoop.hbase.TableName;
49  import org.apache.hadoop.hbase.client.Admin.MasterSwitchType;
50  import org.apache.hadoop.hbase.constraint.ConstraintException;
51  import org.apache.hadoop.hbase.coprocessor.CoprocessorService;
52  import org.apache.hadoop.hbase.coprocessor.MasterCoprocessorEnvironment;
53  import org.apache.hadoop.hbase.coprocessor.MasterObserver;
54  import org.apache.hadoop.hbase.coprocessor.ObserverContext;
55  import org.apache.hadoop.hbase.ipc.RpcServer;
56  import org.apache.hadoop.hbase.master.MasterServices;
57  import org.apache.hadoop.hbase.master.RegionPlan;
58  import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv;
59  import org.apache.hadoop.hbase.net.Address;
60  import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
61  import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
62  import org.apache.hadoop.hbase.protobuf.ResponseConverter;
63  import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos;
64  import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.SnapshotDescription;
65  import org.apache.hadoop.hbase.protobuf.generated.QuotaProtos.Quotas;
66  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos;
67  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.AddRSGroupRequest;
68  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.AddRSGroupResponse;
69  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.BalanceRSGroupRequest;
70  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.BalanceRSGroupResponse;
71  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoOfServerRequest;
72  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoOfServerResponse;
73  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoOfTableRequest;
74  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoOfTableResponse;
75  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoRequest;
76  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.GetRSGroupInfoResponse;
77  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.ListRSGroupInfosRequest;
78  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.ListRSGroupInfosResponse;
79  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.MoveServersAndTablesRequest;
80  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.MoveServersAndTablesResponse;
81  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.MoveServersRequest;
82  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.MoveServersResponse;
83  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.MoveTablesRequest;
84  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.MoveTablesResponse;
85  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RSGroupAdminService;
86  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RemoveRSGroupRequest;
87  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RemoveRSGroupResponse;
88  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RemoveServersRequest;
89  import org.apache.hadoop.hbase.protobuf.generated.RSGroupAdminProtos.RemoveServersResponse;
90  import org.apache.hadoop.hbase.protobuf.generated.TableProtos;
91  import org.apache.hadoop.hbase.security.User;
92  import org.apache.hadoop.hbase.security.UserProvider;
93  import org.apache.hadoop.hbase.security.access.AccessChecker;
94  import org.apache.hadoop.hbase.security.access.Permission;
95  import org.apache.hadoop.hbase.security.access.TableAuthManager;
96  import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher;
97  
98  public class RSGroupAdminEndpoint extends RSGroupAdminService
99      implements CoprocessorService, Coprocessor, MasterObserver {
100 
101   private static final Log LOG = LogFactory.getLog(RSGroupAdminEndpoint.class);
102 
103   private MasterServices master = null;
104 
105   private static RSGroupInfoManagerImpl groupInfoManager;
106   private RSGroupAdminServer groupAdminServer;
107   private AccessChecker accessChecker;
108 
109   /** Provider for mapping principal names to Users */
110   private UserProvider userProvider;
111 
112   @Override
113   public void start(CoprocessorEnvironment env) throws IOException {
114     MasterCoprocessorEnvironment menv = (MasterCoprocessorEnvironment)env;
115     master = menv.getMasterServices();
116     setGroupInfoManager(new RSGroupInfoManagerImpl(master));
117     groupAdminServer = new RSGroupAdminServer(master, groupInfoManager);
118     Class<?> clazz =
119         master.getConfiguration().getClass(HConstants.HBASE_MASTER_LOADBALANCER_CLASS, null);
120     if (!RSGroupableBalancer.class.isAssignableFrom(clazz)) {
121       throw new IOException("Configured balancer is not a GroupableBalancer");
122     }
123     ZooKeeperWatcher zk = menv.getMasterServices().getZooKeeper();
124     accessChecker = new AccessChecker(env.getConfiguration(), zk);
125 
126     // set the user-provider.
127     this.userProvider = UserProvider.instantiate(env.getConfiguration());
128   }
129 
130   @Override
131   public void stop(CoprocessorEnvironment env) {
132     if (accessChecker.getAuthManager() != null) {
133       TableAuthManager.release(accessChecker.getAuthManager());
134     }
135   }
136 
137   @Override
138   public Service getService() {
139     return this;
140   }
141 
142   private static void setStaticGroupInfoManager(RSGroupInfoManagerImpl groupInfoManager) {
143     RSGroupAdminEndpoint.groupInfoManager = groupInfoManager;
144   }
145 
146   private void setGroupInfoManager(RSGroupInfoManagerImpl groupInfoManager) throws IOException {
147     if (groupInfoManager == null) {
148       groupInfoManager = new RSGroupInfoManagerImpl(master);
149       groupInfoManager.init();
150     } else if (!groupInfoManager.isInit()) {
151       groupInfoManager.init();
152     }
153     setStaticGroupInfoManager(groupInfoManager);
154   }
155 
156   public RSGroupInfoManager getGroupInfoManager() {
157     return groupInfoManager;
158   }
159 
160   @Override
161   public void getRSGroupInfo(RpcController controller,
162                            GetRSGroupInfoRequest request,
163                            RpcCallback<GetRSGroupInfoResponse> done) {
164     GetRSGroupInfoResponse response = null;
165     try {
166       GetRSGroupInfoResponse.Builder builder =
167           GetRSGroupInfoResponse.newBuilder();
168       RSGroupInfo RSGroupInfo = groupAdminServer.getRSGroupInfo(request.getRSGroupName());
169       checkPermission("getRSGroupInfo");
170       if(RSGroupInfo != null) {
171         builder.setRSGroupInfo(RSGroupProtobufUtil.toProtoGroupInfo(RSGroupInfo));
172       }
173       response = builder.build();
174     } catch (IOException e) {
175       ResponseConverter.setControllerException(controller, e);
176     }
177     done.run(response);
178   }
179 
180   @Override
181   public void getRSGroupInfoOfTable(RpcController controller,
182                                   GetRSGroupInfoOfTableRequest request,
183                                   RpcCallback<GetRSGroupInfoOfTableResponse> done) {
184     GetRSGroupInfoOfTableResponse response = null;
185     try {
186       GetRSGroupInfoOfTableResponse.Builder builder =
187           GetRSGroupInfoOfTableResponse.newBuilder();
188       TableName tableName = ProtobufUtil.toTableName(request.getTableName());
189       checkPermission("getRSGroupInfoOfTable");
190       RSGroupInfo info = groupAdminServer.getRSGroupInfoOfTable(tableName);
191       if (info == null) {
192         response = builder.build();
193       } else {
194         response = builder.setRSGroupInfo(RSGroupProtobufUtil.toProtoGroupInfo(info)).build();
195       }
196     } catch (IOException e) {
197       ResponseConverter.setControllerException(controller, e);
198     }
199     done.run(response);
200   }
201 
202   @Override
203   public void moveServers(RpcController controller,
204                           MoveServersRequest request,
205                           RpcCallback<MoveServersResponse> done) {
206     RSGroupAdminProtos.MoveServersResponse response = null;
207     try {
208       RSGroupAdminProtos.MoveServersResponse.Builder builder =
209           RSGroupAdminProtos.MoveServersResponse.newBuilder();
210       Set<Address> servers = Sets.newHashSet();
211       for(HBaseProtos.ServerName el: request.getServersList()) {
212         servers.add(Address.fromParts(el.getHostName(), el.getPort()));
213       }
214       if (master.getMasterCoprocessorHost() != null) {
215         master.getMasterCoprocessorHost().preMoveServers(servers, request.getTargetGroup());
216       }
217       checkPermission("moveServers");
218       groupAdminServer.moveServers(servers, request.getTargetGroup());
219       if (master.getMasterCoprocessorHost() != null) {
220         master.getMasterCoprocessorHost().postMoveServers(servers, request.getTargetGroup());
221       }
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 moveTables(RpcController controller,
231                          MoveTablesRequest request,
232                          RpcCallback<MoveTablesResponse> done) {
233     MoveTablesResponse response = null;
234     try {
235       MoveTablesResponse.Builder builder =
236           MoveTablesResponse.newBuilder();
237       Set<TableName> tables = new HashSet<TableName>(request.getTableNameList().size());
238       for(TableProtos.TableName tableName: request.getTableNameList()) {
239         tables.add(ProtobufUtil.toTableName(tableName));
240       }
241       if (master.getMasterCoprocessorHost() != null) {
242         master.getMasterCoprocessorHost().preMoveTables(tables, request.getTargetGroup());
243       }
244       checkPermission("moveTables");
245       groupAdminServer.moveTables(tables, request.getTargetGroup());
246       response = builder.build();
247       if (master.getMasterCoprocessorHost() != null) {
248         master.getMasterCoprocessorHost().postMoveTables(tables, request.getTargetGroup());
249       }
250     } catch (IOException e) {
251       ResponseConverter.setControllerException(controller, e);
252     }
253     done.run(response);
254   }
255 
256   @Override
257   public void moveServersAndTables(RpcController controller, MoveServersAndTablesRequest request,
258       RpcCallback<MoveServersAndTablesResponse> done) {
259     MoveServersAndTablesResponse.Builder builder = MoveServersAndTablesResponse.newBuilder();
260     try {
261       Set<Address> servers = Sets.newHashSet();
262       for (HBaseProtos.ServerName el : request.getServersList()) {
263         servers.add(Address.fromParts(el.getHostName(), el.getPort()));
264       }
265       Set<TableName> tables = new HashSet<>(request.getTableNameList().size());
266       for (TableProtos.TableName tableName : request.getTableNameList()) {
267         tables.add(ProtobufUtil.toTableName(tableName));
268       }
269       if (master.getMasterCoprocessorHost() != null) {
270         master.getMasterCoprocessorHost().preMoveServersAndTables(servers, tables,
271             request.getTargetGroup());
272       }
273       checkPermission("moveServersAndTables");
274       groupAdminServer.moveServersAndTables(servers, tables, request.getTargetGroup());
275       if (master.getMasterCoprocessorHost() != null) {
276         master.getMasterCoprocessorHost().postMoveServersAndTables(servers, tables,
277             request.getTargetGroup());
278       }
279     } catch (IOException e) {
280       ResponseConverter.setControllerException(controller, e);
281     }
282     done.run(builder.build());
283   }
284 
285   @Override
286   public void addRSGroup(RpcController controller,
287                        AddRSGroupRequest request,
288                        RpcCallback<AddRSGroupResponse> done) {
289     AddRSGroupResponse response = null;
290     try {
291       AddRSGroupResponse.Builder builder =
292           AddRSGroupResponse.newBuilder();
293       if (master.getMasterCoprocessorHost() != null) {
294         master.getMasterCoprocessorHost().preAddRSGroup(request.getRSGroupName());
295       }
296       checkPermission("addRSGroup");
297       groupAdminServer.addRSGroup(request.getRSGroupName());
298       response = builder.build();
299       if (master.getMasterCoprocessorHost() != null) {
300         master.getMasterCoprocessorHost().postAddRSGroup(request.getRSGroupName());
301       }
302     } catch (IOException e) {
303       ResponseConverter.setControllerException(controller, e);
304     }
305     done.run(response);
306   }
307 
308   @Override
309   public void removeRSGroup(RpcController controller,
310                           RemoveRSGroupRequest request,
311                           RpcCallback<RemoveRSGroupResponse> done) {
312     RemoveRSGroupResponse response = null;
313     try {
314       RemoveRSGroupResponse.Builder builder =
315           RemoveRSGroupResponse.newBuilder();
316       if (master.getMasterCoprocessorHost() != null) {
317         master.getMasterCoprocessorHost().preRemoveRSGroup(request.getRSGroupName());
318       }
319       checkPermission("removeRSGroup");
320       groupAdminServer.removeRSGroup(request.getRSGroupName());
321       if (master.getMasterCoprocessorHost() != null) {
322         master.getMasterCoprocessorHost().postRemoveRSGroup(request.getRSGroupName());
323       }
324       response = builder.build();
325     } catch (IOException e) {
326       ResponseConverter.setControllerException(controller, e);
327     }
328     done.run(response);
329   }
330 
331   @Override
332   public void balanceRSGroup(RpcController controller,
333                            BalanceRSGroupRequest request,
334                            RpcCallback<BalanceRSGroupResponse> done) {
335     BalanceRSGroupResponse.Builder builder = BalanceRSGroupResponse.newBuilder();
336     try {
337       if (master.getMasterCoprocessorHost() != null) {
338         master.getMasterCoprocessorHost().preBalanceRSGroup(request.getRSGroupName());
339       }
340       checkPermission("balanceRSGroup");
341       boolean balancerRan = groupAdminServer.balanceRSGroup(request.getRSGroupName());
342       builder.setBalanceRan(balancerRan);
343       if (master.getMasterCoprocessorHost() != null) {
344         master.getMasterCoprocessorHost().postBalanceRSGroup(request.getRSGroupName(),
345             balancerRan);
346       }
347     } catch (IOException e) {
348       ResponseConverter.setControllerException(controller, e);
349       builder.setBalanceRan(false);
350     }
351     done.run(builder.build());
352   }
353 
354   @Override
355   public void listRSGroupInfos(RpcController controller,
356                              ListRSGroupInfosRequest request,
357                              RpcCallback<ListRSGroupInfosResponse> done) {
358     ListRSGroupInfosResponse response = null;
359     try {
360       ListRSGroupInfosResponse.Builder builder =
361           ListRSGroupInfosResponse.newBuilder();
362       checkPermission("listRSGroupInfos");
363       for(RSGroupInfo RSGroupInfo : groupAdminServer.listRSGroups()) {
364         builder.addRSGroupInfo(RSGroupProtobufUtil.toProtoGroupInfo(RSGroupInfo));
365       }
366       response = builder.build();
367     } catch (IOException e) {
368       ResponseConverter.setControllerException(controller, e);
369     }
370     done.run(response);
371   }
372 
373   @Override
374   public void getRSGroupInfoOfServer(RpcController controller,
375                                    GetRSGroupInfoOfServerRequest request,
376                                    RpcCallback<GetRSGroupInfoOfServerResponse> done) {
377     GetRSGroupInfoOfServerResponse.Builder builder = GetRSGroupInfoOfServerResponse.newBuilder();
378     try {
379       Address server =
380           Address.fromParts(request.getServer().getHostName(), request.getServer().getPort());
381       checkPermission("getRSGroupInfoOfServer");
382       RSGroupInfo RSGroupInfo = groupAdminServer.getRSGroupOfServer(server);
383       if (RSGroupInfo != null) {
384         builder.setRSGroupInfo(RSGroupProtobufUtil.toProtoGroupInfo(RSGroupInfo));
385       }
386     } catch (IOException e) {
387       ResponseConverter.setControllerException(controller, e);
388     }
389     done.run(builder.build());
390   }
391 
392   @Override
393   public void removeServers(RpcController controller,
394       RemoveServersRequest request,
395       RpcCallback<RemoveServersResponse> done) {
396     RemoveServersResponse.Builder builder =
397         RemoveServersResponse.newBuilder();
398     try {
399       Set<Address> servers = Sets.newHashSet();
400       for (HBaseProtos.ServerName el : request.getServersList()) {
401         servers.add(Address.fromParts(el.getHostName(), el.getPort()));
402       }
403       if (master.getMasterCoprocessorHost() != null) {
404         master.getMasterCoprocessorHost().preRemoveServers(servers);
405       }
406       checkPermission("removeServers");
407       groupAdminServer.removeServers(servers);
408       if (master.getMasterCoprocessorHost() != null) {
409         master.getMasterCoprocessorHost().postRemoveServers(servers);
410       }
411     } catch (IOException e) {
412       ResponseConverter.setControllerException(controller, e);
413     }
414     done.run(builder.build());
415   }
416 
417   void assignTableToGroup(HTableDescriptor desc) throws IOException {
418     String groupName;
419     try {
420       groupName =
421         master.getNamespaceDescriptor(desc.getTableName().getNamespaceAsString())
422                 .getConfigurationValue(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP);
423       if (groupName == null) {
424         groupName = RSGroupInfo.DEFAULT_GROUP;
425       }
426     } catch (MasterNotRunningException | PleaseHoldException e) {
427       LOG.info("Master has not initialized yet; temporarily using default RSGroup '" +
428         RSGroupInfo.DEFAULT_GROUP + "' for deploy of system table");
429       groupName = RSGroupInfo.DEFAULT_GROUP;
430     }
431     RSGroupInfo rsGroupInfo = groupAdminServer.getRSGroupInfo(groupName);
432     if (rsGroupInfo == null) {
433       throw new ConstraintException("Default RSGroup (" + groupName + ") for this table's "
434           + "namespace does not exist.");
435     }
436     if (!rsGroupInfo.containsTable(desc.getTableName())) {
437       groupAdminServer.moveTables(Sets.newHashSet(desc.getTableName()), groupName);
438     }
439   }
440 
441   /////////////////////////////////////////////////////////////////////////////
442   // MasterObserver overrides
443   /////////////////////////////////////////////////////////////////////////////
444 
445   // Assign table to default RSGroup.
446   @Override
447   public void preCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
448       HTableDescriptor desc, HRegionInfo[] regions) throws IOException {
449     groupAdminServer.prepareRSGroupForTable(desc);
450   }
451 
452   // Remove table from its RSGroup.
453   @Override
454   public void postDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
455                               TableName tableName) throws IOException {
456     groupAdminServer.cleanupRSGroupForTable(tableName);
457   }
458 
459   //unused cp hooks
460 
461   @Override
462   public void postCreateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
463                               HTableDescriptor desc,
464                               HRegionInfo[] regions) throws IOException {
465     assignTableToGroup(desc);
466   }
467 
468   @Override
469   public void preCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
470                                     HTableDescriptor desc,
471                                     HRegionInfo[] regions) throws IOException {
472 
473   }
474 
475   @Override
476   public void postCreateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
477                                      HTableDescriptor desc,
478                                      HRegionInfo[] regions) throws IOException {
479 
480   }
481 
482   @Override
483   public void preDeleteTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
484                              TableName tableName) throws IOException {
485 
486   }
487 
488   @Override
489   public void preDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
490                                     TableName tableName) throws IOException {
491 
492   }
493 
494   @Override
495   public void postDeleteTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
496                                      TableName tableName) throws IOException {
497 
498   }
499 
500   @Override
501   public void preTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
502                                TableName tableName) throws IOException {
503 
504   }
505 
506   @Override
507   public void postTruncateTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
508                                 TableName tableName) throws IOException {
509 
510   }
511 
512   @Override
513   public void preTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
514                                       TableName tableName) throws IOException {
515 
516   }
517 
518   @Override
519   public void postTruncateTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
520                                        TableName tableName) throws IOException {
521 
522   }
523 
524   @Override
525   public void preModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName,
526                              HTableDescriptor htd) throws IOException {
527 
528   }
529 
530   @Override
531   public void postModifyTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
532                               TableName tableName, HTableDescriptor htd) throws IOException {
533 
534   }
535 
536   @Override
537   public void preModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
538                                     TableName tableName, HTableDescriptor htd) throws IOException {
539 
540   }
541 
542   @Override
543   public void postModifyTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
544                                      TableName tableName, HTableDescriptor htd) throws IOException {
545 
546   }
547 
548   @Override
549   public void preAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
550                            TableName tableName, HColumnDescriptor column) throws IOException {
551 
552   }
553 
554   @Override
555   public void postAddColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName tableName,
556                             HColumnDescriptor column) throws IOException {
557 
558   }
559 
560   @Override
561   public void preAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
562                                   TableName tableName, HColumnDescriptor column)
563       throws IOException {
564 
565   }
566 
567   @Override
568   public void postAddColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
569                                    TableName tableName, HColumnDescriptor column)
570       throws IOException {
571 
572   }
573 
574   @Override
575   public void preModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
576                               TableName tableName, HColumnDescriptor descriptor)
577       throws IOException {
578 
579   }
580 
581   @Override
582   public void postModifyColumn(ObserverContext<MasterCoprocessorEnvironment> ctx,
583                                TableName tableName, HColumnDescriptor descriptor)
584       throws IOException {
585 
586   }
587 
588   @Override
589   public void preModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
590                                      TableName tableName, HColumnDescriptor descriptor)
591       throws IOException {
592 
593   }
594 
595   @Override
596   public void postModifyColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
597                                       TableName tableName, HColumnDescriptor descriptor)
598       throws IOException {
599 
600   }
601 
602   @Override
603   public void preDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
604       tableName, byte[] c) throws IOException {
605 
606   }
607 
608   @Override
609   public void postDeleteColumn(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
610       tableName, byte[] c) throws IOException {
611 
612   }
613 
614   @Override
615   public void preDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
616       tableName, byte[] c) throws IOException {
617 
618   }
619 
620   @Override
621   public void postDeleteColumnHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
622                                       TableName tableName, byte[] c) throws IOException {
623 
624   }
625 
626   @Override
627   public void preEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
628                              TableName tableName) throws IOException {
629 
630   }
631 
632   @Override
633   public void postEnableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
634                               TableName tableName) throws IOException {
635 
636   }
637 
638   @Override
639   public void preEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
640                                     TableName tableName) throws IOException {
641 
642   }
643 
644   @Override
645   public void postEnableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
646                                      TableName tableName) throws IOException {
647 
648   }
649 
650   @Override
651   public void preDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
652                               TableName tableName) throws IOException {
653 
654   }
655 
656   @Override
657   public void postDisableTable(ObserverContext<MasterCoprocessorEnvironment> ctx,
658                                TableName tableName) throws IOException {
659 
660   }
661 
662   @Override
663   public void preDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
664                                      TableName tableName) throws IOException {
665 
666   }
667 
668   @Override
669   public void postDisableTableHandler(ObserverContext<MasterCoprocessorEnvironment> ctx,
670                                       TableName tableName) throws IOException {
671 
672   }
673 
674   @Override
675   public void preMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region,
676                       ServerName srcServer, ServerName destServer) throws IOException {
677 
678   }
679 
680   @Override
681   public void postMove(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo region,
682                        ServerName srcServer, ServerName destServer) throws IOException {
683 
684   }
685 
686   @Override
687   public void preAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx,
688                                 ProcedureExecutor<MasterProcedureEnv> procEnv,
689                                 long procId) throws IOException {
690 
691   }
692 
693   @Override
694   public void postAbortProcedure(ObserverContext<MasterCoprocessorEnvironment> ctx)
695       throws IOException {
696 
697   }
698 
699   @Override
700   public void preListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx) throws
701       IOException {
702 
703   }
704 
705   @Override
706   public void postListProcedures(ObserverContext<MasterCoprocessorEnvironment> ctx,
707                                  List<ProcedureInfo> procInfoList) throws IOException {
708 
709   }
710 
711   @Override
712   public void preAssign(ObserverContext<MasterCoprocessorEnvironment> ctx,
713                         HRegionInfo regionInfo) throws IOException {
714 
715   }
716 
717   @Override
718   public void postAssign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo
719       regionInfo) throws IOException {
720 
721   }
722 
723   @Override
724   public void preUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx, HRegionInfo
725       regionInfo, boolean force) throws IOException {
726 
727   }
728 
729   @Override
730   public void postUnassign(ObserverContext<MasterCoprocessorEnvironment> ctx,
731                            HRegionInfo regionInfo, boolean force) throws IOException {
732 
733   }
734 
735   @Override
736   public void preRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx,
737                                HRegionInfo regionInfo) throws IOException {
738 
739   }
740 
741   @Override
742   public void postRegionOffline(ObserverContext<MasterCoprocessorEnvironment> ctx,
743                                 HRegionInfo regionInfo) throws IOException {
744 
745   }
746 
747   @Override
748   public void preBalance(ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
749 
750   }
751 
752   @Override
753   public void postBalance(ObserverContext<MasterCoprocessorEnvironment> ctx,
754                           List<RegionPlan> plans) throws IOException {
755 
756   }
757 
758   @Override
759   public boolean preSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
760                                            boolean newValue, MasterSwitchType switchType) throws
761       IOException {
762     return false;
763   }
764 
765   @Override
766   public void postSetSplitOrMergeEnabled(ObserverContext<MasterCoprocessorEnvironment> ctx,
767                                          boolean newValue, MasterSwitchType switchType) throws
768       IOException {
769 
770   }
771 
772   @Override
773   public boolean preBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx,
774                                   boolean newValue) throws IOException {
775     return newValue;
776   }
777 
778   @Override
779   public void postBalanceSwitch(ObserverContext<MasterCoprocessorEnvironment> ctx, boolean
780       oldValue, boolean newValue) throws IOException {
781 
782   }
783 
784   @Override
785   public void preShutdown(ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
786 
787   }
788 
789   @Override
790   public void preStopMaster(ObserverContext<MasterCoprocessorEnvironment> ctx) throws IOException {
791 
792   }
793 
794   @Override
795   public void postStartMaster(ObserverContext<MasterCoprocessorEnvironment> ctx)
796       throws IOException {
797 
798   }
799 
800   @Override
801   public void preMasterInitialization(ObserverContext<MasterCoprocessorEnvironment> ctx)
802       throws IOException {
803 
804   }
805 
806   @Override
807   public void preSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
808                           SnapshotDescription snapshot,
809                           HTableDescriptor hTableDescriptor) throws IOException {
810 
811 
812   }
813 
814   @Override
815   public void postSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx, SnapshotDescription
816       snapshot, HTableDescriptor hTableDescriptor) throws IOException {
817 
818   }
819 
820   @Override
821   public void preListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
822                               SnapshotDescription snapshot) throws IOException {
823 
824   }
825 
826   @Override
827   public void postListSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
828                                SnapshotDescription snapshot) throws IOException {
829 
830   }
831 
832   @Override
833   public void preCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
834                                SnapshotDescription snapshot,
835                                HTableDescriptor hTableDescriptor) throws IOException {
836     assignTableToGroup(hTableDescriptor);
837   }
838 
839   @Override
840   public void postCloneSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
841                                 SnapshotDescription snapshot,
842                                 HTableDescriptor hTableDescriptor) throws IOException {
843 
844   }
845 
846   @Override
847   public void preRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
848                                  SnapshotDescription snapshot,
849                                  HTableDescriptor hTableDescriptor) throws IOException {
850 
851   }
852 
853   @Override
854   public void postRestoreSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
855                                   SnapshotDescription snapshot,
856                                   HTableDescriptor hTableDescriptor) throws IOException {
857 
858   }
859 
860   @Override
861   public void preDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
862                                 SnapshotDescription snapshot) throws IOException {
863 
864   }
865 
866   @Override
867   public void postDeleteSnapshot(ObserverContext<MasterCoprocessorEnvironment> ctx,
868                                  SnapshotDescription snapshot) throws IOException {
869 
870   }
871 
872   @Override
873   public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
874                                      List<TableName> tableNamesList,
875                                      List<HTableDescriptor> descriptors) throws IOException {
876 
877   }
878 
879   @Override
880   public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
881                                       List<HTableDescriptor> descriptors) throws IOException {
882 
883   }
884 
885   @Override
886   public void preGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
887                                      List<TableName> tableNamesList,
888                                      List<HTableDescriptor> descriptors,
889                                      String regex) throws IOException {
890 
891   }
892 
893   @Override
894   public void postGetTableDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
895                                       List<TableName> tableNamesList,
896                                       List<HTableDescriptor> descriptors,
897                                       String regex) throws IOException {
898 
899   }
900 
901   @Override
902   public void preGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
903                                List<HTableDescriptor> descriptors,
904                                String regex) throws IOException {
905 
906   }
907 
908   @Override
909   public void postGetTableNames(ObserverContext<MasterCoprocessorEnvironment> ctx,
910                                 List<HTableDescriptor> descriptors,
911                                 String regex) throws IOException {
912 
913   }
914 
915   @Override
916   public void preCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
917                                  NamespaceDescriptor ns) throws IOException {
918     String group = ns.getConfigurationValue(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP);
919     if(group != null && groupAdminServer.getRSGroupInfo(group) == null) {
920       throw new ConstraintException("Region server group "+group+" does not exit");
921     }
922   }
923 
924   @Override
925   public void postCreateNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
926                                   NamespaceDescriptor ns) throws IOException {
927 
928   }
929 
930   @Override
931   public void preDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
932                                  String namespace) throws IOException {
933 
934   }
935 
936   @Override
937   public void postDeleteNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
938                                   String namespace) throws IOException {
939 
940   }
941 
942   @Override
943   public void preModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
944                                  NamespaceDescriptor ns) throws IOException {
945     preCreateNamespace(ctx, ns);
946   }
947 
948   @Override
949   public void postModifyNamespace(ObserverContext<MasterCoprocessorEnvironment> ctx,
950                                   NamespaceDescriptor ns) throws IOException {
951 
952   }
953 
954   @Override
955   public void preGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
956                                         String namespace) throws IOException {
957 
958   }
959 
960   @Override
961   public void postGetNamespaceDescriptor(ObserverContext<MasterCoprocessorEnvironment> ctx,
962                                          NamespaceDescriptor ns) throws IOException {
963 
964   }
965 
966   @Override
967   public void preListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
968                                           List<NamespaceDescriptor> descriptors)
969       throws IOException {
970 
971   }
972 
973   @Override
974   public void postListNamespaceDescriptors(ObserverContext<MasterCoprocessorEnvironment> ctx,
975                                            List<NamespaceDescriptor> descriptors)
976       throws IOException {
977 
978   }
979 
980   @Override
981   public void preTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx, TableName
982       tableName) throws IOException {
983 
984   }
985 
986   @Override
987   public void postTableFlush(ObserverContext<MasterCoprocessorEnvironment> ctx,
988                              TableName tableName) throws IOException {
989 
990   }
991 
992   @Override
993   public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
994                               Quotas quotas) throws IOException {
995 
996   }
997 
998   @Override
999   public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
1000                                String userName, Quotas quotas) throws IOException {
1001 
1002   }
1003 
1004   @Override
1005   public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
1006                               TableName tableName, Quotas quotas) throws IOException {
1007 
1008   }
1009 
1010   @Override
1011   public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String
1012       userName, TableName tableName, Quotas quotas) throws IOException {
1013 
1014   }
1015 
1016   @Override
1017   public void preSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
1018                               String namespace, Quotas quotas) throws IOException {
1019 
1020   }
1021 
1022   @Override
1023   public void postSetUserQuota(ObserverContext<MasterCoprocessorEnvironment> ctx, String userName,
1024                                String namespace, Quotas quotas) throws IOException {
1025 
1026   }
1027 
1028   @Override
1029   public void preSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
1030                                TableName tableName, Quotas quotas) throws IOException {
1031 
1032   }
1033 
1034   @Override
1035   public void postSetTableQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
1036                                 TableName tableName, Quotas quotas) throws IOException {
1037 
1038   }
1039 
1040   @Override
1041   public void preSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
1042                                    String namespace, Quotas quotas) throws IOException {
1043 
1044   }
1045 
1046   @Override
1047   public void postSetNamespaceQuota(ObserverContext<MasterCoprocessorEnvironment> ctx,
1048                                     String namespace, Quotas quotas) throws IOException {
1049 
1050   }
1051 
1052   @Override
1053   public void preDispatchMerge(ObserverContext<MasterCoprocessorEnvironment> ctx,
1054                                HRegionInfo regionA, HRegionInfo regionB) throws IOException {
1055 
1056   }
1057 
1058   @Override
1059   public void postDispatchMerge(ObserverContext<MasterCoprocessorEnvironment> c,
1060                                 HRegionInfo regionA, HRegionInfo regionB) throws IOException {
1061 
1062   }
1063 
1064   @Override
1065   public void preGetClusterStatus(ObserverContext<MasterCoprocessorEnvironment> ctx)
1066       throws IOException {
1067   }
1068 
1069   @Override
1070   public void postGetClusterStatus(ObserverContext<MasterCoprocessorEnvironment> ctx,
1071       ClusterStatus status) throws IOException {
1072   }
1073 
1074   @Override
1075   public void preClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx)
1076       throws IOException {
1077 
1078   }
1079 
1080   @Override
1081   public void postClearDeadServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
1082       List<ServerName> servers, List<ServerName> notClearedServers)
1083       throws IOException {
1084     Set<Address> clearedServer = Sets.newHashSet();
1085     for (ServerName server: servers) {
1086       if (!notClearedServers.contains(server)) {
1087         clearedServer.add(server.getAddress());
1088       }
1089     }
1090     groupAdminServer.removeServers(clearedServer);
1091   }
1092 
1093   @Override
1094   public void preMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
1095                              Set<Address> servers, String targetGroup) throws IOException {
1096 
1097   }
1098 
1099   @Override
1100   public void postMoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
1101                               Set<Address> servers, String targetGroup) throws IOException {
1102 
1103   }
1104 
1105   @Override
1106   public void preMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx, Set<TableName>
1107       tables, String targetGroup) throws IOException {
1108 
1109   }
1110 
1111   @Override
1112   public void postMoveTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
1113                              Set<TableName> tables, String targetGroup) throws IOException {
1114 
1115   }
1116 
1117   @Override
1118   public void preMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
1119       Set<Address> servers, Set<TableName> tables, String targetGroup) throws IOException {
1120   }
1121 
1122   @Override
1123   public void postMoveServersAndTables(ObserverContext<MasterCoprocessorEnvironment> ctx,
1124       Set<Address> servers, Set<TableName> tables, String targetGroup) throws IOException {
1125   }
1126 
1127   @Override
1128   public void preRemoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
1129       Set<Address> servers) throws IOException {
1130   }
1131 
1132   @Override
1133   public void postRemoveServers(ObserverContext<MasterCoprocessorEnvironment> ctx,
1134       Set<Address> servers) throws IOException {
1135   }
1136 
1137   @Override
1138   public void preAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
1139                             String name) throws IOException {
1140 
1141   }
1142 
1143   @Override
1144   public void postAddRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
1145                              String name) throws IOException {
1146 
1147   }
1148 
1149   @Override
1150   public void preRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
1151                                String name) throws IOException {
1152 
1153   }
1154 
1155   @Override
1156   public void postRemoveRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
1157                                 String name) throws IOException {
1158 
1159   }
1160 
1161   @Override
1162   public void preBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
1163                                 String groupName) throws IOException {
1164 
1165   }
1166 
1167   @Override
1168   public void postBalanceRSGroup(ObserverContext<MasterCoprocessorEnvironment> ctx,
1169                                  String groupName, boolean balancerRan) throws IOException {
1170 
1171   }
1172 
1173   public void checkPermission(String request) throws IOException {
1174     accessChecker.requirePermission(getActiveUser(), request, Permission.Action.ADMIN);
1175   }
1176 
1177   /**
1178    * Returns the active user to which authorization checks should be applied.
1179    * If we are in the context of an RPC call, the remote user is used,
1180    * otherwise the currently logged in user is used.
1181    */
1182   private User getActiveUser() throws IOException {
1183     User user = RpcServer.getRequestUser();
1184     if (user == null) {
1185       // for non-rpc handling, fallback to system user
1186       user = userProvider.getCurrent();
1187     }
1188     return user;
1189   }
1190 }