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 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
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 }