1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 package org.apache.hadoop.hbase.protobuf;
19
20 import java.io.IOException;
21 import java.util.List;
22 import java.util.regex.Pattern;
23
24 import org.apache.hadoop.hbase.util.ByteStringer;
25
26 import org.apache.hadoop.hbase.backup.BackupType;
27 import org.apache.hadoop.hbase.classification.InterfaceAudience;
28 import org.apache.hadoop.hbase.CellScannable;
29 import org.apache.hadoop.hbase.DoNotRetryIOException;
30 import org.apache.hadoop.hbase.HColumnDescriptor;
31 import org.apache.hadoop.hbase.HConstants;
32 import org.apache.hadoop.hbase.HRegionInfo;
33 import org.apache.hadoop.hbase.HTableDescriptor;
34 import org.apache.hadoop.hbase.ServerName;
35 import org.apache.hadoop.hbase.TableName;
36 import org.apache.hadoop.hbase.client.Action;
37 import org.apache.hadoop.hbase.client.Admin;
38 import org.apache.hadoop.hbase.client.Append;
39 import org.apache.hadoop.hbase.client.Delete;
40 import org.apache.hadoop.hbase.client.Durability;
41 import org.apache.hadoop.hbase.client.Get;
42 import org.apache.hadoop.hbase.client.Increment;
43 import org.apache.hadoop.hbase.client.Mutation;
44 import org.apache.hadoop.hbase.client.Put;
45 import org.apache.hadoop.hbase.client.RegionCoprocessorServiceExec;
46 import org.apache.hadoop.hbase.client.Row;
47 import org.apache.hadoop.hbase.client.RowMutations;
48 import org.apache.hadoop.hbase.client.Scan;
49 import org.apache.hadoop.hbase.exceptions.DeserializationException;
50 import org.apache.hadoop.hbase.filter.ByteArrayComparable;
51 import org.apache.hadoop.hbase.protobuf.generated.AccessControlProtos;
52 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.CloseRegionRequest;
53 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.WarmupRegionRequest;
54 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.CompactRegionRequest;
55 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.FlushRegionRequest;
56 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.GetOnlineRegionRequest;
57 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.GetRegionInfoRequest;
58 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.GetServerInfoRequest;
59 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.GetStoreFileRequest;
60 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.MergeRegionsRequest;
61 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.OpenRegionRequest;
62 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.OpenRegionRequest.RegionOpenInfo;
63 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.RollWALWriterRequest;
64 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.SplitRegionRequest;
65 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.StopServerRequest;
66 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.UpdateFavoredNodesRequest;
67 import org.apache.hadoop.hbase.protobuf.generated.AdminProtos.UpdateFavoredNodesRequest.RegionUpdateInfo;
68 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos;
69 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.BulkLoadHFileRequest;
70 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.BulkLoadHFileRequest.FamilyPath;
71 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.Column;
72 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.Condition;
73 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.GetRequest;
74 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.MutateRequest;
75 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.MutationProto;
76 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.MutationProto.ColumnValue;
77 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.MutationProto.ColumnValue.QualifierValue;
78 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.MutationProto.MutationType;
79 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.RegionAction;
80 import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.ScanRequest;
81 import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.CompareType;
82 import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionSpecifier;
83 import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionSpecifier.RegionSpecifierType;
84 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos;
85 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.AddColumnRequest;
86 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.AssignRegionRequest;
87 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.BackupTablesRequest;
88 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.BalanceRequest;
89 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.CreateTableRequest;
90 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.DeleteColumnRequest;
91 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.DeleteTableRequest;
92 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.DisableTableRequest;
93 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.DispatchMergingRegionsRequest;
94 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.EnableCatalogJanitorRequest;
95 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.EnableTableRequest;
96 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.GetClusterStatusRequest;
97 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.GetSchemaAlterStatusRequest;
98 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.GetTableDescriptorsRequest;
99 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.GetTableNamesRequest;
100 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.IsBalancerEnabledRequest;
101 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.IsCatalogJanitorEnabledRequest;
102 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.IsMasterRunningRequest;
103 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.IsNormalizerEnabledRequest;
104 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.IsSplitOrMergeEnabledRequest;
105 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.ModifyColumnRequest;
106 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.ModifyTableRequest;
107 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.MoveRegionRequest;
108 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.NormalizeRequest;
109 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.OfflineRegionRequest;
110 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.RunCatalogScanRequest;
111 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.SetBalancerRunningRequest;
112 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.SetNormalizerRunningRequest;
113 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.SetSplitOrMergeEnabledRequest;
114 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.TruncateTableRequest;
115 import org.apache.hadoop.hbase.protobuf.generated.MasterProtos.UnassignRegionRequest;
116 import org.apache.hadoop.hbase.protobuf.generated.RegionServerStatusProtos.GetLastFlushedSequenceIdRequest;
117 import org.apache.hadoop.hbase.util.ByteStringer;
118 import org.apache.hadoop.hbase.util.Bytes;
119 import org.apache.hadoop.hbase.util.EnvironmentEdgeManager;
120 import org.apache.hadoop.hbase.util.Pair;
121 import org.apache.hadoop.hbase.util.Triple;
122
123 import com.google.protobuf.ByteString;
124
125
126
127
128
129 @InterfaceAudience.Private
130 public final class RequestConverter {
131
132 private RequestConverter() {
133 }
134
135
136
137
138
139
140
141
142
143
144
145
146
147 public static GetRequest buildGetRowOrBeforeRequest(
148 final byte[] regionName, final byte[] row, final byte[] family) {
149 GetRequest.Builder builder = GetRequest.newBuilder();
150 RegionSpecifier region = buildRegionSpecifier(
151 RegionSpecifierType.REGION_NAME, regionName);
152 builder.setRegion(region);
153
154 Column.Builder columnBuilder = Column.newBuilder();
155 columnBuilder.setFamily(ByteStringer.wrap(family));
156 ClientProtos.Get.Builder getBuilder =
157 ClientProtos.Get.newBuilder();
158 getBuilder.setRow(ByteStringer.wrap(row));
159 getBuilder.addColumn(columnBuilder.build());
160 getBuilder.setClosestRowBefore(true);
161 builder.setGet(getBuilder.build());
162 return builder.build();
163 }
164
165
166
167
168
169
170
171
172
173 public static GetRequest buildGetRequest(final byte[] regionName,
174 final Get get) throws IOException {
175 GetRequest.Builder builder = GetRequest.newBuilder();
176 RegionSpecifier region = buildRegionSpecifier(
177 RegionSpecifierType.REGION_NAME, regionName);
178 builder.setRegion(region);
179 builder.setGet(ProtobufUtil.toGet(get));
180 return builder.build();
181 }
182
183
184
185
186
187
188
189
190
191
192
193
194 public static MutateRequest buildIncrementRequest(
195 final byte[] regionName, final byte[] row, final byte[] family, final byte[] qualifier,
196 final long amount, final Durability durability, long nonceGroup, long nonce) {
197 MutateRequest.Builder builder = MutateRequest.newBuilder();
198 RegionSpecifier region = buildRegionSpecifier(
199 RegionSpecifierType.REGION_NAME, regionName);
200 builder.setRegion(region);
201
202 MutationProto.Builder mutateBuilder = MutationProto.newBuilder();
203 mutateBuilder.setRow(ByteStringer.wrap(row));
204 mutateBuilder.setMutateType(MutationType.INCREMENT);
205 mutateBuilder.setDurability(ProtobufUtil.toDurability(durability));
206 ColumnValue.Builder columnBuilder = ColumnValue.newBuilder();
207 columnBuilder.setFamily(ByteStringer.wrap(family));
208 QualifierValue.Builder valueBuilder = QualifierValue.newBuilder();
209 valueBuilder.setValue(ByteStringer.wrap(Bytes.toBytes(amount)));
210 valueBuilder.setQualifier(ByteStringer.wrap(qualifier));
211 columnBuilder.addQualifierValue(valueBuilder.build());
212 mutateBuilder.addColumnValue(columnBuilder.build());
213 if (nonce != HConstants.NO_NONCE) {
214 mutateBuilder.setNonce(nonce);
215 }
216 builder.setMutation(mutateBuilder.build());
217 if (nonceGroup != HConstants.NO_NONCE) {
218 builder.setNonceGroup(nonceGroup);
219 }
220 return builder.build();
221 }
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236 public static MutateRequest buildMutateRequest(
237 final byte[] regionName, final byte[] row, final byte[] family,
238 final byte [] qualifier, final ByteArrayComparable comparator,
239 final CompareType compareType, final Put put) throws IOException {
240 MutateRequest.Builder builder = MutateRequest.newBuilder();
241 RegionSpecifier region = buildRegionSpecifier(
242 RegionSpecifierType.REGION_NAME, regionName);
243 builder.setRegion(region);
244 Condition condition = buildCondition(
245 row, family, qualifier, comparator, compareType);
246 builder.setMutation(ProtobufUtil.toMutation(MutationType.PUT, put, MutationProto.newBuilder()));
247 builder.setCondition(condition);
248 return builder.build();
249 }
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264 public static MutateRequest buildMutateRequest(
265 final byte[] regionName, final byte[] row, final byte[] family,
266 final byte [] qualifier, final ByteArrayComparable comparator,
267 final CompareType compareType, final Delete delete) throws IOException {
268 MutateRequest.Builder builder = MutateRequest.newBuilder();
269 RegionSpecifier region = buildRegionSpecifier(
270 RegionSpecifierType.REGION_NAME, regionName);
271 builder.setRegion(region);
272 Condition condition = buildCondition(
273 row, family, qualifier, comparator, compareType);
274 builder.setMutation(ProtobufUtil.toMutation(MutationType.DELETE, delete,
275 MutationProto.newBuilder()));
276 builder.setCondition(condition);
277 return builder.build();
278 }
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293 public static ClientProtos.MultiRequest buildMutateRequest(
294 final byte[] regionName, final byte[] row, final byte[] family,
295 final byte [] qualifier, final ByteArrayComparable comparator,
296 final CompareType compareType, final RowMutations rowMutations) throws IOException {
297 RegionAction.Builder builder =
298 getRegionActionBuilderWithRegion(RegionAction.newBuilder(), regionName);
299 builder.setAtomic(true);
300 ClientProtos.Action.Builder actionBuilder = ClientProtos.Action.newBuilder();
301 MutationProto.Builder mutationBuilder = MutationProto.newBuilder();
302 Condition condition = buildCondition(
303 row, family, qualifier, comparator, compareType);
304 for (Mutation mutation: rowMutations.getMutations()) {
305 MutationType mutateType = null;
306 if (mutation instanceof Put) {
307 mutateType = MutationType.PUT;
308 } else if (mutation instanceof Delete) {
309 mutateType = MutationType.DELETE;
310 } else {
311 throw new DoNotRetryIOException("RowMutations supports only put and delete, not " +
312 mutation.getClass().getName());
313 }
314 mutationBuilder.clear();
315 MutationProto mp = ProtobufUtil.toMutation(mutateType, mutation, mutationBuilder);
316 actionBuilder.clear();
317 actionBuilder.setMutation(mp);
318 builder.addAction(actionBuilder.build());
319 }
320 ClientProtos.MultiRequest request =
321 ClientProtos.MultiRequest.newBuilder().addRegionAction(builder.build())
322 .setCondition(condition).build();
323 return request;
324 }
325
326
327
328
329
330
331
332
333
334 public static MutateRequest buildMutateRequest(
335 final byte[] regionName, final Put put) throws IOException {
336 MutateRequest.Builder builder = MutateRequest.newBuilder();
337 RegionSpecifier region = buildRegionSpecifier(
338 RegionSpecifierType.REGION_NAME, regionName);
339 builder.setRegion(region);
340 builder.setMutation(ProtobufUtil.toMutation(MutationType.PUT, put, MutationProto.newBuilder()));
341 return builder.build();
342 }
343
344
345
346
347
348
349
350
351
352 public static MutateRequest buildMutateRequest(final byte[] regionName,
353 final Append append, long nonceGroup, long nonce) throws IOException {
354 MutateRequest.Builder builder = MutateRequest.newBuilder();
355 RegionSpecifier region = buildRegionSpecifier(
356 RegionSpecifierType.REGION_NAME, regionName);
357 builder.setRegion(region);
358 if (nonce != HConstants.NO_NONCE && nonceGroup != HConstants.NO_NONCE) {
359 builder.setNonceGroup(nonceGroup);
360 }
361 builder.setMutation(ProtobufUtil.toMutation(MutationType.APPEND, append,
362 MutationProto.newBuilder(), nonce));
363 return builder.build();
364 }
365
366
367
368
369
370
371
372
373 public static MutateRequest buildMutateRequest(final byte[] regionName,
374 final Increment increment, final long nonceGroup, final long nonce) {
375 MutateRequest.Builder builder = MutateRequest.newBuilder();
376 RegionSpecifier region = buildRegionSpecifier(
377 RegionSpecifierType.REGION_NAME, regionName);
378 builder.setRegion(region);
379 if (nonce != HConstants.NO_NONCE && nonceGroup != HConstants.NO_NONCE) {
380 builder.setNonceGroup(nonceGroup);
381 }
382 builder.setMutation(ProtobufUtil.toMutation(increment, MutationProto.newBuilder(), nonce));
383 return builder.build();
384 }
385
386
387
388
389
390
391
392
393
394 public static MutateRequest buildMutateRequest(
395 final byte[] regionName, final Delete delete) throws IOException {
396 MutateRequest.Builder builder = MutateRequest.newBuilder();
397 RegionSpecifier region = buildRegionSpecifier(
398 RegionSpecifierType.REGION_NAME, regionName);
399 builder.setRegion(region);
400 builder.setMutation(ProtobufUtil.toMutation(MutationType.DELETE, delete,
401 MutationProto.newBuilder()));
402 return builder.build();
403 }
404
405
406
407
408
409
410
411
412
413
414 public static RegionAction.Builder buildRegionAction(final byte [] regionName,
415 final RowMutations rowMutations)
416 throws IOException {
417 RegionAction.Builder builder =
418 getRegionActionBuilderWithRegion(RegionAction.newBuilder(), regionName);
419 ClientProtos.Action.Builder actionBuilder = ClientProtos.Action.newBuilder();
420 MutationProto.Builder mutationBuilder = MutationProto.newBuilder();
421 for (Mutation mutation: rowMutations.getMutations()) {
422 MutationType mutateType = null;
423 if (mutation instanceof Put) {
424 mutateType = MutationType.PUT;
425 } else if (mutation instanceof Delete) {
426 mutateType = MutationType.DELETE;
427 } else {
428 throw new DoNotRetryIOException("RowMutations supports only put and delete, not " +
429 mutation.getClass().getName());
430 }
431 mutationBuilder.clear();
432 MutationProto mp = ProtobufUtil.toMutation(mutateType, mutation, mutationBuilder);
433 actionBuilder.clear();
434 actionBuilder.setMutation(mp);
435 builder.addAction(actionBuilder.build());
436 }
437 return builder;
438 }
439
440
441
442
443
444
445
446
447
448
449
450
451 public static RegionAction.Builder buildNoDataRegionAction(final byte[] regionName,
452 final RowMutations rowMutations, final List<CellScannable> cells,
453 final RegionAction.Builder regionActionBuilder,
454 final ClientProtos.Action.Builder actionBuilder,
455 final MutationProto.Builder mutationBuilder)
456 throws IOException {
457 for (Mutation mutation: rowMutations.getMutations()) {
458 MutationType type = null;
459 if (mutation instanceof Put) {
460 type = MutationType.PUT;
461 } else if (mutation instanceof Delete) {
462 type = MutationType.DELETE;
463 } else {
464 throw new DoNotRetryIOException("RowMutations supports only put and delete, not " +
465 mutation.getClass().getName());
466 }
467 mutationBuilder.clear();
468 MutationProto mp = ProtobufUtil.toMutationNoData(type, mutation, mutationBuilder);
469 cells.add(mutation);
470 actionBuilder.clear();
471 regionActionBuilder.addAction(actionBuilder.setMutation(mp).build());
472 }
473 return regionActionBuilder;
474 }
475
476 private static RegionAction.Builder getRegionActionBuilderWithRegion(
477 final RegionAction.Builder regionActionBuilder, final byte [] regionName) {
478 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName);
479 regionActionBuilder.setRegion(region);
480 return regionActionBuilder;
481 }
482
483
484
485
486
487
488
489
490
491
492
493 public static ScanRequest buildScanRequest(final byte[] regionName,
494 final Scan scan, final int numberOfRows,
495 final boolean closeScanner) throws IOException {
496 ScanRequest.Builder builder = ScanRequest.newBuilder();
497 RegionSpecifier region = buildRegionSpecifier(
498 RegionSpecifierType.REGION_NAME, regionName);
499 builder.setNumberOfRows(numberOfRows);
500 builder.setCloseScanner(closeScanner);
501 builder.setRegion(region);
502 builder.setScan(ProtobufUtil.toScan(scan));
503 builder.setClientHandlesPartials(true);
504 builder.setClientHandlesHeartbeats(true);
505 return builder.build();
506 }
507
508
509
510
511
512
513
514
515
516 public static ScanRequest buildScanRequest(final long scannerId,
517 final int numberOfRows, final boolean closeScanner) {
518 ScanRequest.Builder builder = ScanRequest.newBuilder();
519 builder.setNumberOfRows(numberOfRows);
520 builder.setCloseScanner(closeScanner);
521 builder.setScannerId(scannerId);
522 builder.setClientHandlesPartials(true);
523 builder.setClientHandlesHeartbeats(true);
524 return builder.build();
525 }
526
527
528
529
530
531
532
533
534
535
536 public static ScanRequest buildScanRequest(final long scannerId, final int numberOfRows,
537 final boolean closeScanner, final long nextCallSeq, final boolean renew) {
538 ScanRequest.Builder builder = ScanRequest.newBuilder();
539 builder.setNumberOfRows(numberOfRows);
540 builder.setCloseScanner(closeScanner);
541 builder.setScannerId(scannerId);
542 builder.setNextCallSeq(nextCallSeq);
543 builder.setClientHandlesPartials(true);
544 builder.setClientHandlesHeartbeats(true);
545 builder.setRenew(renew);
546 return builder.build();
547 }
548
549
550
551
552
553
554
555
556
557 public static BulkLoadHFileRequest buildBulkLoadHFileRequest(
558 final List<Pair<byte[], String>> familyPaths,
559 final byte[] regionName, boolean assignSeqNum) {
560 BulkLoadHFileRequest.Builder builder = BulkLoadHFileRequest.newBuilder();
561 RegionSpecifier region = buildRegionSpecifier(
562 RegionSpecifierType.REGION_NAME, regionName);
563 builder.setRegion(region);
564 FamilyPath.Builder familyPathBuilder = FamilyPath.newBuilder();
565 for (Pair<byte[], String> familyPath: familyPaths) {
566 familyPathBuilder.setFamily(ByteStringer.wrap(familyPath.getFirst()));
567 familyPathBuilder.setPath(familyPath.getSecond());
568 builder.addFamilyPath(familyPathBuilder.build());
569 }
570 builder.setAssignSeqNum(assignSeqNum);
571 return builder.build();
572 }
573
574
575
576
577
578
579
580
581
582
583 public static <R> RegionAction.Builder buildRegionAction(final byte[] regionName,
584 final List<Action<R>> actions, final RegionAction.Builder regionActionBuilder,
585 final ClientProtos.Action.Builder actionBuilder,
586 final MutationProto.Builder mutationBuilder) throws IOException {
587 for (Action<R> action: actions) {
588 Row row = action.getAction();
589 actionBuilder.clear();
590 actionBuilder.setIndex(action.getOriginalIndex());
591 mutationBuilder.clear();
592 if (row instanceof Get) {
593 Get g = (Get)row;
594 regionActionBuilder.addAction(actionBuilder.setGet(ProtobufUtil.toGet(g)));
595 } else if (row instanceof Put) {
596 regionActionBuilder.addAction(actionBuilder.
597 setMutation(ProtobufUtil.toMutation(MutationType.PUT, (Put)row, mutationBuilder)));
598 } else if (row instanceof Delete) {
599 regionActionBuilder.addAction(actionBuilder.
600 setMutation(ProtobufUtil.toMutation(MutationType.DELETE, (Delete)row, mutationBuilder)));
601 } else if (row instanceof Append) {
602 regionActionBuilder.addAction(actionBuilder.setMutation(ProtobufUtil.toMutation(
603 MutationType.APPEND, (Append)row, mutationBuilder, action.getNonce())));
604 } else if (row instanceof Increment) {
605 regionActionBuilder.addAction(actionBuilder.setMutation(
606 ProtobufUtil.toMutation((Increment)row, mutationBuilder, action.getNonce())));
607 } else if (row instanceof RegionCoprocessorServiceExec) {
608 RegionCoprocessorServiceExec exec = (RegionCoprocessorServiceExec) row;
609 regionActionBuilder.addAction(actionBuilder.setServiceCall(
610 ClientProtos.CoprocessorServiceCall.newBuilder()
611 .setRow(ByteStringer.wrap(exec.getRow()))
612 .setServiceName(exec.getMethod().getService().getFullName())
613 .setMethodName(exec.getMethod().getName())
614 .setRequest(exec.getRequest().toByteString())));
615 } else if (row instanceof RowMutations) {
616 throw new UnsupportedOperationException("No RowMutations in multi calls; use mutateRow");
617 } else {
618 throw new DoNotRetryIOException("Multi doesn't support " + row.getClass().getName());
619 }
620 }
621 return regionActionBuilder;
622 }
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640 public static <R> RegionAction.Builder buildNoDataRegionAction(final byte[] regionName,
641 final List<Action<R>> actions, final List<CellScannable> cells,
642 final RegionAction.Builder regionActionBuilder,
643 final ClientProtos.Action.Builder actionBuilder,
644 final MutationProto.Builder mutationBuilder) throws IOException {
645 RegionAction.Builder builder = getRegionActionBuilderWithRegion(
646 RegionAction.newBuilder(), regionName);
647 for (Action<R> action: actions) {
648 Row row = action.getAction();
649 actionBuilder.clear();
650 actionBuilder.setIndex(action.getOriginalIndex());
651 mutationBuilder.clear();
652 if (row instanceof Get) {
653 Get g = (Get)row;
654 builder.addAction(actionBuilder.setGet(ProtobufUtil.toGet(g)));
655 } else if (row instanceof Put) {
656 Put p = (Put)row;
657 cells.add(p);
658 builder.addAction(actionBuilder.
659 setMutation(ProtobufUtil.toMutationNoData(MutationType.PUT, p, mutationBuilder)));
660 } else if (row instanceof Delete) {
661 Delete d = (Delete)row;
662 int size = d.size();
663
664
665
666
667
668 if (size > 0) {
669 cells.add(d);
670 builder.addAction(actionBuilder.
671 setMutation(ProtobufUtil.toMutationNoData(MutationType.DELETE, d, mutationBuilder)));
672 } else {
673 builder.addAction(actionBuilder.
674 setMutation(ProtobufUtil.toMutation(MutationType.DELETE, d, mutationBuilder)));
675 }
676 } else if (row instanceof Append) {
677 Append a = (Append)row;
678 cells.add(a);
679 builder.addAction(actionBuilder.setMutation(ProtobufUtil.toMutationNoData(
680 MutationType.APPEND, a, mutationBuilder, action.getNonce())));
681 } else if (row instanceof Increment) {
682 Increment i = (Increment)row;
683 cells.add(i);
684 builder.addAction(actionBuilder.setMutation(ProtobufUtil.toMutationNoData(
685 MutationType.INCREMENT, i, mutationBuilder, action.getNonce())));
686 } else if (row instanceof RowMutations) {
687 continue;
688 } else {
689 throw new DoNotRetryIOException("Multi doesn't support " + row.getClass().getName());
690 }
691 }
692 return builder;
693 }
694
695
696
697
698
699
700
701
702
703
704 public static GetRegionInfoRequest
705 buildGetRegionInfoRequest(final byte[] regionName) {
706 return buildGetRegionInfoRequest(regionName, false);
707 }
708
709
710
711
712
713
714
715
716 public static GetRegionInfoRequest
717 buildGetRegionInfoRequest(final byte[] regionName,
718 final boolean includeCompactionState) {
719 GetRegionInfoRequest.Builder builder = GetRegionInfoRequest.newBuilder();
720 RegionSpecifier region = buildRegionSpecifier(
721 RegionSpecifierType.REGION_NAME, regionName);
722 builder.setRegion(region);
723 if (includeCompactionState) {
724 builder.setCompactionState(includeCompactionState);
725 }
726 return builder.build();
727 }
728
729
730
731
732
733
734
735
736 public static GetStoreFileRequest
737 buildGetStoreFileRequest(final byte[] regionName, final byte[] family) {
738 GetStoreFileRequest.Builder builder = GetStoreFileRequest.newBuilder();
739 RegionSpecifier region = buildRegionSpecifier(
740 RegionSpecifierType.REGION_NAME, regionName);
741 builder.setRegion(region);
742 builder.addFamily(ByteStringer.wrap(family));
743 return builder.build();
744 }
745
746
747
748
749
750
751 public static GetOnlineRegionRequest buildGetOnlineRegionRequest() {
752 return GetOnlineRegionRequest.newBuilder().build();
753 }
754
755
756
757
758
759
760
761 public static FlushRegionRequest
762 buildFlushRegionRequest(final byte[] regionName) {
763 return buildFlushRegionRequest(regionName, false);
764 }
765
766
767
768
769
770
771
772 public static FlushRegionRequest
773 buildFlushRegionRequest(final byte[] regionName, boolean writeFlushWALMarker) {
774 FlushRegionRequest.Builder builder = FlushRegionRequest.newBuilder();
775 RegionSpecifier region = buildRegionSpecifier(
776 RegionSpecifierType.REGION_NAME, regionName);
777 builder.setRegion(region);
778 builder.setWriteFlushWalMarker(writeFlushWALMarker);
779 return builder.build();
780 }
781
782
783
784
785
786
787
788
789
790 public static OpenRegionRequest
791 buildOpenRegionRequest(ServerName server, final List<Triple<HRegionInfo, Integer,
792 List<ServerName>>> regionOpenInfos, Boolean openForReplay) {
793 OpenRegionRequest.Builder builder = OpenRegionRequest.newBuilder();
794 for (Triple<HRegionInfo, Integer, List<ServerName>> regionOpenInfo: regionOpenInfos) {
795 Integer second = regionOpenInfo.getSecond();
796 int versionOfOfflineNode = second == null ? -1 : second.intValue();
797 builder.addOpenInfo(buildRegionOpenInfo(regionOpenInfo.getFirst(), versionOfOfflineNode,
798 regionOpenInfo.getThird(), openForReplay));
799 }
800 if (server != null) {
801 builder.setServerStartCode(server.getStartcode());
802 }
803
804 builder.setMasterSystemTime(EnvironmentEdgeManager.currentTime());
805 return builder.build();
806 }
807
808
809
810
811
812
813
814
815
816
817
818 public static OpenRegionRequest buildOpenRegionRequest(ServerName server,
819 final HRegionInfo region, final int versionOfOfflineNode, List<ServerName> favoredNodes,
820 Boolean openForReplay) {
821 OpenRegionRequest.Builder builder = OpenRegionRequest.newBuilder();
822 builder.addOpenInfo(buildRegionOpenInfo(region, versionOfOfflineNode, favoredNodes,
823 openForReplay));
824 if (server != null) {
825 builder.setServerStartCode(server.getStartcode());
826 }
827 builder.setMasterSystemTime(EnvironmentEdgeManager.currentTime());
828 return builder.build();
829 }
830
831
832
833
834
835
836 public static UpdateFavoredNodesRequest buildUpdateFavoredNodesRequest(
837 final List<Pair<HRegionInfo, List<ServerName>>> updateRegionInfos) {
838 UpdateFavoredNodesRequest.Builder ubuilder = UpdateFavoredNodesRequest.newBuilder();
839 for (Pair<HRegionInfo, List<ServerName>> pair : updateRegionInfos) {
840 RegionUpdateInfo.Builder builder = RegionUpdateInfo.newBuilder();
841 builder.setRegion(HRegionInfo.convert(pair.getFirst()));
842 for (ServerName server : pair.getSecond()) {
843 builder.addFavoredNodes(ProtobufUtil.toServerName(server));
844 }
845 ubuilder.addUpdateInfo(builder.build());
846 }
847 return ubuilder.build();
848 }
849
850
851
852
853
854
855
856
857 public static CloseRegionRequest buildCloseRegionRequest(ServerName server,
858 final byte[] regionName, final boolean transitionInZK) {
859 CloseRegionRequest.Builder builder = CloseRegionRequest.newBuilder();
860 RegionSpecifier region = buildRegionSpecifier(
861 RegionSpecifierType.REGION_NAME, regionName);
862 builder.setRegion(region);
863 builder.setTransitionInZK(transitionInZK);
864 if (server != null) {
865 builder.setServerStartCode(server.getStartcode());
866 }
867 return builder.build();
868 }
869
870 public static CloseRegionRequest buildCloseRegionRequest(ServerName server,
871 final byte[] regionName, final int versionOfClosingNode,
872 ServerName destinationServer, final boolean transitionInZK) {
873 CloseRegionRequest.Builder builder = CloseRegionRequest.newBuilder();
874 RegionSpecifier region = buildRegionSpecifier(
875 RegionSpecifierType.REGION_NAME, regionName);
876 builder.setRegion(region);
877 builder.setVersionOfClosingNode(versionOfClosingNode);
878 builder.setTransitionInZK(transitionInZK);
879 if (destinationServer != null){
880 builder.setDestinationServer(ProtobufUtil.toServerName( destinationServer) );
881 }
882 if (server != null) {
883 builder.setServerStartCode(server.getStartcode());
884 }
885 return builder.build();
886 }
887
888
889
890
891
892
893 public static WarmupRegionRequest buildWarmupRegionRequest(final HRegionInfo regionInfo) {
894 WarmupRegionRequest.Builder builder = WarmupRegionRequest.newBuilder();
895 builder.setRegionInfo(HRegionInfo.convert(regionInfo));
896 return builder.build();
897 }
898
899
900
901
902
903
904
905 public static CloseRegionRequest
906 buildCloseRegionRequest(ServerName server, final String encodedRegionName,
907 final boolean transitionInZK) {
908 CloseRegionRequest.Builder builder = CloseRegionRequest.newBuilder();
909 RegionSpecifier region = buildRegionSpecifier(
910 RegionSpecifierType.ENCODED_REGION_NAME,
911 Bytes.toBytes(encodedRegionName));
912 builder.setRegion(region);
913 builder.setTransitionInZK(transitionInZK);
914 if (server != null) {
915 builder.setServerStartCode(server.getStartcode());
916 }
917 return builder.build();
918 }
919
920
921
922
923
924
925
926
927 public static SplitRegionRequest buildSplitRegionRequest(
928 final byte[] regionName, final byte[] splitPoint) {
929 SplitRegionRequest.Builder builder = SplitRegionRequest.newBuilder();
930 RegionSpecifier region = buildRegionSpecifier(
931 RegionSpecifierType.REGION_NAME, regionName);
932 builder.setRegion(region);
933 if (splitPoint != null) {
934 builder.setSplitPoint(ByteStringer.wrap(splitPoint));
935 }
936 return builder.build();
937 }
938
939
940
941
942
943
944
945
946 public static MergeRegionsRequest buildMergeRegionsRequest(
947 final byte[] regionA, final byte[] regionB, final boolean forcible) {
948 MergeRegionsRequest.Builder builder = MergeRegionsRequest.newBuilder();
949 RegionSpecifier regionASpecifier = buildRegionSpecifier(
950 RegionSpecifierType.REGION_NAME, regionA);
951 RegionSpecifier regionBSpecifier = buildRegionSpecifier(
952 RegionSpecifierType.REGION_NAME, regionB);
953 builder.setRegionA(regionASpecifier);
954 builder.setRegionB(regionBSpecifier);
955 builder.setForcible(forcible);
956
957 builder.setMasterSystemTime(EnvironmentEdgeManager.currentTime());
958 return builder.build();
959 }
960
961
962
963
964
965
966
967
968 public static CompactRegionRequest buildCompactRegionRequest(
969 final byte[] regionName, final boolean major, final byte [] family) {
970 CompactRegionRequest.Builder builder = CompactRegionRequest.newBuilder();
971 RegionSpecifier region = buildRegionSpecifier(
972 RegionSpecifierType.REGION_NAME, regionName);
973 builder.setRegion(region);
974 builder.setMajor(major);
975 if (family != null) {
976 builder.setFamily(ByteStringer.wrap(family));
977 }
978 return builder.build();
979 }
980
981
982
983
984 private static RollWALWriterRequest ROLL_WAL_WRITER_REQUEST =
985 RollWALWriterRequest.newBuilder().build();
986
987
988
989
990
991
992 public static RollWALWriterRequest buildRollWALWriterRequest() {
993 return ROLL_WAL_WRITER_REQUEST;
994 }
995
996
997
998
999 private static GetServerInfoRequest GET_SERVER_INFO_REQUEST =
1000 GetServerInfoRequest.newBuilder().build();
1001
1002
1003
1004
1005
1006
1007 public static GetServerInfoRequest buildGetServerInfoRequest() {
1008 return GET_SERVER_INFO_REQUEST;
1009 }
1010
1011
1012
1013
1014
1015
1016
1017 public static StopServerRequest buildStopServerRequest(final String reason) {
1018 StopServerRequest.Builder builder = StopServerRequest.newBuilder();
1019 builder.setReason(reason);
1020 return builder.build();
1021 }
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032 public static RegionSpecifier buildRegionSpecifier(
1033 final RegionSpecifierType type, final byte[] value) {
1034 RegionSpecifier.Builder regionBuilder = RegionSpecifier.newBuilder();
1035 regionBuilder.setValue(ByteStringer.wrap(value));
1036 regionBuilder.setType(type);
1037 return regionBuilder.build();
1038 }
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051 private static Condition buildCondition(final byte[] row,
1052 final byte[] family, final byte [] qualifier,
1053 final ByteArrayComparable comparator,
1054 final CompareType compareType) throws IOException {
1055 Condition.Builder builder = Condition.newBuilder();
1056 builder.setRow(ByteStringer.wrap(row));
1057 builder.setFamily(ByteStringer.wrap(family));
1058 builder.setQualifier(ByteStringer.wrap(qualifier));
1059 builder.setComparator(ProtobufUtil.toComparator(comparator));
1060 builder.setCompareType(compareType);
1061 return builder.build();
1062 }
1063
1064
1065
1066
1067
1068
1069
1070
1071 public static AddColumnRequest buildAddColumnRequest(
1072 final TableName tableName, final HColumnDescriptor column) {
1073 AddColumnRequest.Builder builder = AddColumnRequest.newBuilder();
1074 builder.setTableName(ProtobufUtil.toProtoTableName(tableName));
1075 builder.setColumnFamilies(column.convert());
1076 return builder.build();
1077 }
1078
1079
1080
1081
1082
1083
1084
1085
1086 public static DeleteColumnRequest buildDeleteColumnRequest(
1087 final TableName tableName, final byte [] columnName) {
1088 DeleteColumnRequest.Builder builder = DeleteColumnRequest.newBuilder();
1089 builder.setTableName(ProtobufUtil.toProtoTableName((tableName)));
1090 builder.setColumnName(ByteStringer.wrap(columnName));
1091 return builder.build();
1092 }
1093
1094
1095
1096
1097
1098
1099
1100
1101 public static ModifyColumnRequest buildModifyColumnRequest(
1102 final TableName tableName, final HColumnDescriptor column) {
1103 ModifyColumnRequest.Builder builder = ModifyColumnRequest.newBuilder();
1104 builder.setTableName(ProtobufUtil.toProtoTableName((tableName)));
1105 builder.setColumnFamilies(column.convert());
1106 return builder.build();
1107 }
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117 public static MoveRegionRequest buildMoveRegionRequest(
1118 final byte [] encodedRegionName, final byte [] destServerName) throws
1119 DeserializationException {
1120 MoveRegionRequest.Builder builder = MoveRegionRequest.newBuilder();
1121 builder.setRegion(
1122 buildRegionSpecifier(RegionSpecifierType.ENCODED_REGION_NAME,encodedRegionName));
1123 if (destServerName != null) {
1124 builder.setDestServerName(
1125 ProtobufUtil.toServerName(ServerName.valueOf(Bytes.toString(destServerName))));
1126 }
1127 return builder.build();
1128 }
1129
1130 public static DispatchMergingRegionsRequest buildDispatchMergingRegionsRequest(
1131 final byte[] encodedNameOfRegionA, final byte[] encodedNameOfRegionB,
1132 final boolean forcible) throws DeserializationException {
1133 DispatchMergingRegionsRequest.Builder builder = DispatchMergingRegionsRequest.newBuilder();
1134 builder.setRegionA(buildRegionSpecifier(
1135 RegionSpecifierType.ENCODED_REGION_NAME, encodedNameOfRegionA));
1136 builder.setRegionB(buildRegionSpecifier(
1137 RegionSpecifierType.ENCODED_REGION_NAME, encodedNameOfRegionB));
1138 builder.setForcible(forcible);
1139 return builder.build();
1140 }
1141
1142
1143
1144
1145
1146
1147
1148 public static AssignRegionRequest buildAssignRegionRequest(final byte [] regionName) {
1149 AssignRegionRequest.Builder builder = AssignRegionRequest.newBuilder();
1150 builder.setRegion(buildRegionSpecifier(RegionSpecifierType.REGION_NAME,regionName));
1151 return builder.build();
1152 }
1153
1154
1155
1156
1157
1158
1159
1160
1161 public static UnassignRegionRequest buildUnassignRegionRequest(
1162 final byte [] regionName, final boolean force) {
1163 UnassignRegionRequest.Builder builder = UnassignRegionRequest.newBuilder();
1164 builder.setRegion(buildRegionSpecifier(RegionSpecifierType.REGION_NAME,regionName));
1165 builder.setForce(force);
1166 return builder.build();
1167 }
1168
1169
1170
1171
1172
1173
1174
1175 public static OfflineRegionRequest buildOfflineRegionRequest(final byte [] regionName) {
1176 OfflineRegionRequest.Builder builder = OfflineRegionRequest.newBuilder();
1177 builder.setRegion(buildRegionSpecifier(RegionSpecifierType.REGION_NAME,regionName));
1178 return builder.build();
1179 }
1180
1181
1182
1183
1184
1185
1186
1187 public static DeleteTableRequest buildDeleteTableRequest(final TableName tableName) {
1188 DeleteTableRequest.Builder builder = DeleteTableRequest.newBuilder();
1189 builder.setTableName(ProtobufUtil.toProtoTableName(tableName));
1190 return builder.build();
1191 }
1192
1193
1194
1195
1196
1197
1198
1199
1200 public static TruncateTableRequest buildTruncateTableRequest(final TableName tableName,
1201 boolean preserveSplits) {
1202 TruncateTableRequest.Builder builder = TruncateTableRequest.newBuilder();
1203 builder.setTableName(ProtobufUtil.toProtoTableName(tableName));
1204 builder.setPreserveSplits(preserveSplits);
1205 return builder.build();
1206 }
1207
1208
1209
1210
1211
1212
1213
1214 public static EnableTableRequest buildEnableTableRequest(final TableName tableName) {
1215 EnableTableRequest.Builder builder = EnableTableRequest.newBuilder();
1216 builder.setTableName(ProtobufUtil.toProtoTableName(tableName));
1217 return builder.build();
1218 }
1219
1220
1221
1222
1223
1224
1225
1226 public static DisableTableRequest buildDisableTableRequest(final TableName tableName) {
1227 DisableTableRequest.Builder builder = DisableTableRequest.newBuilder();
1228 builder.setTableName(ProtobufUtil.toProtoTableName((tableName)));
1229 return builder.build();
1230 }
1231
1232
1233
1234
1235
1236
1237
1238
1239 public static CreateTableRequest buildCreateTableRequest(
1240 final HTableDescriptor hTableDesc, final byte [][] splitKeys) {
1241 CreateTableRequest.Builder builder = CreateTableRequest.newBuilder();
1242 builder.setTableSchema(hTableDesc.convert());
1243 if (splitKeys != null) {
1244 for (byte [] splitKey : splitKeys) {
1245 builder.addSplitKeys(ByteStringer.wrap(splitKey));
1246 }
1247 }
1248 return builder.build();
1249 }
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259 public static ModifyTableRequest buildModifyTableRequest(
1260 final TableName tableName, final HTableDescriptor hTableDesc) {
1261 ModifyTableRequest.Builder builder = ModifyTableRequest.newBuilder();
1262 builder.setTableName(ProtobufUtil.toProtoTableName((tableName)));
1263 builder.setTableSchema(hTableDesc.convert());
1264 return builder.build();
1265 }
1266
1267 public static BackupTablesRequest buildBackupTablesRequest(
1268 final BackupType type, List<TableName> tableList, String targetRootDir, final int workers,
1269 final long bandwidth) {
1270 BackupTablesRequest.Builder builder = BackupTablesRequest.newBuilder();
1271 builder.setType(ProtobufUtil.toProtoBackupType(type));
1272 builder.setTargetRootDir(targetRootDir);
1273 builder.setWorkers(workers);
1274 builder.setBandwidth(bandwidth);
1275 if (tableList != null) {
1276 for (TableName table : tableList) {
1277 builder.addTables(ProtobufUtil.toProtoTableName(table));
1278 }
1279 }
1280 return builder.build();
1281 }
1282
1283
1284
1285
1286
1287
1288
1289 public static GetSchemaAlterStatusRequest buildGetSchemaAlterStatusRequest(
1290 final TableName tableName) {
1291 GetSchemaAlterStatusRequest.Builder builder = GetSchemaAlterStatusRequest.newBuilder();
1292 builder.setTableName(ProtobufUtil.toProtoTableName((tableName)));
1293 return builder.build();
1294 }
1295
1296
1297
1298
1299
1300
1301
1302 public static GetTableDescriptorsRequest buildGetTableDescriptorsRequest(
1303 final List<TableName> tableNames) {
1304 GetTableDescriptorsRequest.Builder builder = GetTableDescriptorsRequest.newBuilder();
1305 if (tableNames != null) {
1306 for (TableName tableName : tableNames) {
1307 builder.addTableNames(ProtobufUtil.toProtoTableName(tableName));
1308 }
1309 }
1310 return builder.build();
1311 }
1312
1313
1314
1315
1316
1317
1318
1319
1320 public static GetTableDescriptorsRequest buildGetTableDescriptorsRequest(final Pattern pattern,
1321 boolean includeSysTables) {
1322 GetTableDescriptorsRequest.Builder builder = GetTableDescriptorsRequest.newBuilder();
1323 if (pattern != null) builder.setRegex(pattern.toString());
1324 builder.setIncludeSysTables(includeSysTables);
1325 return builder.build();
1326 }
1327
1328
1329
1330
1331
1332
1333
1334
1335 public static GetTableNamesRequest buildGetTableNamesRequest(final Pattern pattern,
1336 boolean includeSysTables) {
1337 GetTableNamesRequest.Builder builder = GetTableNamesRequest.newBuilder();
1338 if (pattern != null) builder.setRegex(pattern.toString());
1339 builder.setIncludeSysTables(includeSysTables);
1340 return builder.build();
1341 }
1342
1343
1344
1345
1346
1347
1348
1349 public static GetTableDescriptorsRequest buildGetTableDescriptorsRequest(
1350 final TableName tableName) {
1351 return GetTableDescriptorsRequest.newBuilder()
1352 .addTableNames(ProtobufUtil.toProtoTableName(tableName))
1353 .build();
1354 }
1355
1356
1357
1358
1359
1360
1361 public static IsMasterRunningRequest buildIsMasterRunningRequest() {
1362 return IsMasterRunningRequest.newBuilder().build();
1363 }
1364
1365
1366
1367
1368
1369
1370 public static BalanceRequest buildBalanceRequest(boolean force) {
1371 return BalanceRequest.newBuilder().setForce(force).build();
1372 }
1373
1374
1375
1376
1377
1378
1379
1380
1381 public static SetBalancerRunningRequest buildSetBalancerRunningRequest(boolean on, boolean synchronous) {
1382 return SetBalancerRunningRequest.newBuilder().setOn(on).setSynchronous(synchronous).build();
1383 }
1384
1385
1386
1387
1388
1389
1390 public static IsBalancerEnabledRequest buildIsBalancerEnabledRequest() {
1391 return IsBalancerEnabledRequest.newBuilder().build();
1392 }
1393
1394
1395
1396
1397 private static final GetClusterStatusRequest GET_CLUSTER_STATUS_REQUEST =
1398 GetClusterStatusRequest.newBuilder().build();
1399
1400
1401
1402
1403
1404
1405 public static GetClusterStatusRequest buildGetClusterStatusRequest() {
1406 return GET_CLUSTER_STATUS_REQUEST;
1407 }
1408
1409
1410
1411
1412 private static final RunCatalogScanRequest CATALOG_SCAN_REQUEST =
1413 RunCatalogScanRequest.newBuilder().build();
1414
1415
1416
1417
1418
1419 public static RunCatalogScanRequest buildCatalogScanRequest() {
1420 return CATALOG_SCAN_REQUEST;
1421 }
1422
1423
1424
1425
1426
1427 public static EnableCatalogJanitorRequest buildEnableCatalogJanitorRequest(boolean enable) {
1428 return EnableCatalogJanitorRequest.newBuilder().setEnable(enable).build();
1429 }
1430
1431
1432
1433
1434 private static final IsCatalogJanitorEnabledRequest IS_CATALOG_JANITOR_ENABLED_REQUEST =
1435 IsCatalogJanitorEnabledRequest.newBuilder().build();
1436
1437
1438
1439
1440
1441 public static IsCatalogJanitorEnabledRequest buildIsCatalogJanitorEnabledRequest() {
1442 return IS_CATALOG_JANITOR_ENABLED_REQUEST;
1443 }
1444
1445
1446
1447
1448
1449
1450 public static GetLastFlushedSequenceIdRequest buildGetLastFlushedSequenceIdRequest(
1451 byte[] regionName) {
1452 return GetLastFlushedSequenceIdRequest.newBuilder().setRegionName(
1453 ByteStringer.wrap(regionName)).build();
1454 }
1455
1456
1457
1458
1459
1460
1461
1462
1463 public static AccessControlProtos.GrantRequest buildGrantRequest(
1464 String username, AccessControlProtos.Permission.Action... actions) {
1465 AccessControlProtos.Permission.Builder ret =
1466 AccessControlProtos.Permission.newBuilder();
1467 AccessControlProtos.GlobalPermission.Builder permissionBuilder =
1468 AccessControlProtos.GlobalPermission.newBuilder();
1469 for (AccessControlProtos.Permission.Action a : actions) {
1470 permissionBuilder.addAction(a);
1471 }
1472 ret.setType(AccessControlProtos.Permission.Type.Global)
1473 .setGlobalPermission(permissionBuilder);
1474 return AccessControlProtos.GrantRequest.newBuilder()
1475 .setUserPermission(
1476 AccessControlProtos.UserPermission.newBuilder()
1477 .setUser(ByteString.copyFromUtf8(username))
1478 .setPermission(ret)
1479 ).build();
1480 }
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492 public static AccessControlProtos.GrantRequest buildGrantRequest(
1493 String username, TableName tableName, byte[] family, byte[] qualifier,
1494 AccessControlProtos.Permission.Action... actions) {
1495 AccessControlProtos.Permission.Builder ret =
1496 AccessControlProtos.Permission.newBuilder();
1497 AccessControlProtos.TablePermission.Builder permissionBuilder =
1498 AccessControlProtos.TablePermission.newBuilder();
1499 for (AccessControlProtos.Permission.Action a : actions) {
1500 permissionBuilder.addAction(a);
1501 }
1502 if (tableName == null) {
1503 throw new NullPointerException("TableName cannot be null");
1504 }
1505 permissionBuilder.setTableName(ProtobufUtil.toProtoTableName(tableName));
1506
1507 if (family != null) {
1508 permissionBuilder.setFamily(ByteStringer.wrap(family));
1509 }
1510 if (qualifier != null) {
1511 permissionBuilder.setQualifier(ByteStringer.wrap(qualifier));
1512 }
1513 ret.setType(AccessControlProtos.Permission.Type.Table)
1514 .setTablePermission(permissionBuilder);
1515 return AccessControlProtos.GrantRequest.newBuilder()
1516 .setUserPermission(
1517 AccessControlProtos.UserPermission.newBuilder()
1518 .setUser(ByteString.copyFromUtf8(username))
1519 .setPermission(ret)
1520 ).build();
1521 }
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531 public static AccessControlProtos.GrantRequest buildGrantRequest(
1532 String username, String namespace,
1533 AccessControlProtos.Permission.Action... actions) {
1534 AccessControlProtos.Permission.Builder ret =
1535 AccessControlProtos.Permission.newBuilder();
1536 AccessControlProtos.NamespacePermission.Builder permissionBuilder =
1537 AccessControlProtos.NamespacePermission.newBuilder();
1538 for (AccessControlProtos.Permission.Action a : actions) {
1539 permissionBuilder.addAction(a);
1540 }
1541 if (namespace != null) {
1542 permissionBuilder.setNamespaceName(ByteString.copyFromUtf8(namespace));
1543 }
1544 ret.setType(AccessControlProtos.Permission.Type.Namespace)
1545 .setNamespacePermission(permissionBuilder);
1546 return AccessControlProtos.GrantRequest.newBuilder()
1547 .setUserPermission(
1548 AccessControlProtos.UserPermission.newBuilder()
1549 .setUser(ByteString.copyFromUtf8(username))
1550 .setPermission(ret)
1551 ).build();
1552 }
1553
1554
1555
1556
1557
1558
1559
1560
1561 public static AccessControlProtos.RevokeRequest buildRevokeRequest(
1562 String username, AccessControlProtos.Permission.Action... actions) {
1563 AccessControlProtos.Permission.Builder ret =
1564 AccessControlProtos.Permission.newBuilder();
1565 AccessControlProtos.GlobalPermission.Builder permissionBuilder =
1566 AccessControlProtos.GlobalPermission.newBuilder();
1567 for (AccessControlProtos.Permission.Action a : actions) {
1568 permissionBuilder.addAction(a);
1569 }
1570 ret.setType(AccessControlProtos.Permission.Type.Global)
1571 .setGlobalPermission(permissionBuilder);
1572 return AccessControlProtos.RevokeRequest.newBuilder()
1573 .setUserPermission(
1574 AccessControlProtos.UserPermission.newBuilder()
1575 .setUser(ByteString.copyFromUtf8(username))
1576 .setPermission(ret)
1577 ).build();
1578 }
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590 public static AccessControlProtos.RevokeRequest buildRevokeRequest(
1591 String username, TableName tableName, byte[] family, byte[] qualifier,
1592 AccessControlProtos.Permission.Action... actions) {
1593 AccessControlProtos.Permission.Builder ret =
1594 AccessControlProtos.Permission.newBuilder();
1595 AccessControlProtos.TablePermission.Builder permissionBuilder =
1596 AccessControlProtos.TablePermission.newBuilder();
1597 for (AccessControlProtos.Permission.Action a : actions) {
1598 permissionBuilder.addAction(a);
1599 }
1600 if (tableName != null) {
1601 permissionBuilder.setTableName(ProtobufUtil.toProtoTableName(tableName));
1602 }
1603 if (family != null) {
1604 permissionBuilder.setFamily(ByteStringer.wrap(family));
1605 }
1606 if (qualifier != null) {
1607 permissionBuilder.setQualifier(ByteStringer.wrap(qualifier));
1608 }
1609 ret.setType(AccessControlProtos.Permission.Type.Table)
1610 .setTablePermission(permissionBuilder);
1611 return AccessControlProtos.RevokeRequest.newBuilder()
1612 .setUserPermission(
1613 AccessControlProtos.UserPermission.newBuilder()
1614 .setUser(ByteString.copyFromUtf8(username))
1615 .setPermission(ret)
1616 ).build();
1617 }
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627 public static AccessControlProtos.RevokeRequest buildRevokeRequest(
1628 String username, String namespace,
1629 AccessControlProtos.Permission.Action... actions) {
1630 AccessControlProtos.Permission.Builder ret =
1631 AccessControlProtos.Permission.newBuilder();
1632 AccessControlProtos.NamespacePermission.Builder permissionBuilder =
1633 AccessControlProtos.NamespacePermission.newBuilder();
1634 for (AccessControlProtos.Permission.Action a : actions) {
1635 permissionBuilder.addAction(a);
1636 }
1637 if (namespace != null) {
1638 permissionBuilder.setNamespaceName(ByteString.copyFromUtf8(namespace));
1639 }
1640 ret.setType(AccessControlProtos.Permission.Type.Namespace)
1641 .setNamespacePermission(permissionBuilder);
1642 return AccessControlProtos.RevokeRequest.newBuilder()
1643 .setUserPermission(
1644 AccessControlProtos.UserPermission.newBuilder()
1645 .setUser(ByteString.copyFromUtf8(username))
1646 .setPermission(ret)
1647 ).build();
1648 }
1649
1650
1651
1652
1653 private static RegionOpenInfo buildRegionOpenInfo(
1654 final HRegionInfo region, final int versionOfOfflineNode,
1655 final List<ServerName> favoredNodes, Boolean openForReplay) {
1656 RegionOpenInfo.Builder builder = RegionOpenInfo.newBuilder();
1657 builder.setRegion(HRegionInfo.convert(region));
1658 if (versionOfOfflineNode >= 0) {
1659 builder.setVersionOfOfflineNode(versionOfOfflineNode);
1660 }
1661 if (favoredNodes != null) {
1662 for (ServerName server : favoredNodes) {
1663 builder.addFavoredNodes(ProtobufUtil.toServerName(server));
1664 }
1665 }
1666 if(openForReplay != null) {
1667 builder.setOpenForDistributedLogReplay(openForReplay);
1668 }
1669 return builder.build();
1670 }
1671
1672
1673
1674
1675
1676
1677 public static NormalizeRequest buildNormalizeRequest() {
1678 return NormalizeRequest.newBuilder().build();
1679 }
1680
1681
1682
1683
1684
1685
1686 public static IsNormalizerEnabledRequest buildIsNormalizerEnabledRequest() {
1687 return IsNormalizerEnabledRequest.newBuilder().build();
1688 }
1689
1690
1691
1692
1693
1694
1695
1696 public static SetNormalizerRunningRequest buildSetNormalizerRunningRequest(boolean on) {
1697 return SetNormalizerRunningRequest.newBuilder().setOn(on).build();
1698 }
1699
1700
1701
1702
1703
1704
1705
1706 public static IsSplitOrMergeEnabledRequest buildIsSplitOrMergeEnabledRequest(
1707 Admin.MasterSwitchType switchType) {
1708 IsSplitOrMergeEnabledRequest.Builder builder = IsSplitOrMergeEnabledRequest.newBuilder();
1709 builder.setSwitchType(convert(switchType));
1710 return builder.build();
1711 }
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722 public static SetSplitOrMergeEnabledRequest buildSetSplitOrMergeEnabledRequest(boolean enabled,
1723 boolean synchronous, Admin.MasterSwitchType... switchTypes) {
1724 SetSplitOrMergeEnabledRequest.Builder builder = SetSplitOrMergeEnabledRequest.newBuilder();
1725 builder.setEnabled(enabled);
1726 builder.setSynchronous(synchronous);
1727 for (Admin.MasterSwitchType switchType : switchTypes) {
1728 builder.addSwitchTypes(convert(switchType));
1729 }
1730 return builder.build();
1731 }
1732
1733 private static MasterProtos.MasterSwitchType convert(Admin.MasterSwitchType switchType) {
1734 switch (switchType) {
1735 case SPLIT:
1736 return MasterProtos.MasterSwitchType.SPLIT;
1737 case MERGE:
1738 return MasterProtos.MasterSwitchType.MERGE;
1739 default:
1740 break;
1741 }
1742 throw new UnsupportedOperationException("Unsupport switch type:" + switchType);
1743 }
1744 }