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