View Javadoc

1   /**
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
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  * Helper utility to build protocol buffer requests,
127  * or build components for protocol buffer requests.
128  */
129 @InterfaceAudience.Private
130 public final class RequestConverter {
131 
132   private RequestConverter() {
133   }
134 
135 // Start utilities for Client
136 
137 /**
138    * Create a new protocol buffer GetRequest to get a row, all columns in a family.
139    * If there is no such row, return the closest row before it.
140    *
141    * @param regionName the name of the region to get
142    * @param row the row to get
143    * @param family the column family to get
144    * should return the immediate row before
145    * @return a protocol buffer GetReuqest
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    * Create a protocol buffer GetRequest for a client Get
168    *
169    * @param regionName the name of the region to get
170    * @param get the client Get
171    * @return a protocol buffer GetRequest
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    * Create a protocol buffer MutateRequest for a client increment
185    *
186    * @param regionName
187    * @param row
188    * @param family
189    * @param qualifier
190    * @param amount
191    * @param durability
192    * @return a mutate request
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    * Create a protocol buffer MutateRequest for a conditioned put
225    *
226    * @param regionName
227    * @param row
228    * @param family
229    * @param qualifier
230    * @param comparator
231    * @param compareType
232    * @param put
233    * @return a mutate request
234    * @throws IOException
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    * Create a protocol buffer MutateRequest for a conditioned delete
253    *
254    * @param regionName
255    * @param row
256    * @param family
257    * @param qualifier
258    * @param comparator
259    * @param compareType
260    * @param delete
261    * @return a mutate request
262    * @throws IOException
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    * Create a protocol buffer MutateRequest for conditioned row mutations
282    *
283    * @param regionName
284    * @param row
285    * @param family
286    * @param qualifier
287    * @param comparator
288    * @param compareType
289    * @param rowMutations
290    * @return a mutate request
291    * @throws IOException
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    * Create a protocol buffer MutateRequest for a put
328    *
329    * @param regionName
330    * @param put
331    * @return a mutate request
332    * @throws IOException
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    * Create a protocol buffer MutateRequest for an append
346    *
347    * @param regionName
348    * @param append
349    * @return a mutate request
350    * @throws IOException
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    * Create a protocol buffer MutateRequest for a client increment
368    *
369    * @param regionName
370    * @param increment
371    * @return a mutate request
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    * Create a protocol buffer MutateRequest for a delete
388    *
389    * @param regionName
390    * @param delete
391    * @return a mutate request
392    * @throws IOException
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    * Create a protocol buffer MultiRequest for row mutations.
407    * Does not propagate Action absolute position.  Does not set atomic action on the created
408    * RegionAtomic.  Caller should do that if wanted.
409    * @param regionName
410    * @param rowMutations
411    * @return a data-laden RegionMutation.Builder
412    * @throws IOException
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    * Create a protocol buffer MultiRequest for row mutations that does not hold data.  Data/Cells
442    * are carried outside of protobuf.  Return references to the Cells in <code>cells</code> param.
443     * Does not propagate Action absolute position.  Does not set atomic action on the created
444    * RegionAtomic.  Caller should do that if wanted.
445    * @param regionName
446    * @param rowMutations
447    * @param cells Return in here a list of Cells as CellIterable.
448    * @return a region mutation minus data
449    * @throws IOException
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    * Create a protocol buffer ScanRequest for a client Scan
485    *
486    * @param regionName
487    * @param scan
488    * @param numberOfRows
489    * @param closeScanner
490    * @return a scan request
491    * @throws IOException
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    * Create a protocol buffer ScanRequest for a scanner id
510    *
511    * @param scannerId
512    * @param numberOfRows
513    * @param closeScanner
514    * @return a scan request
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    * Create a protocol buffer ScanRequest for a scanner id
529    *
530    * @param scannerId
531    * @param numberOfRows
532    * @param closeScanner
533    * @param nextCallSeq
534    * @return a scan request
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    * Create a protocol buffer bulk load request
551    *
552    * @param familyPaths
553    * @param regionName
554    * @param assignSeqNum
555    * @return a bulk load request
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    * Create a protocol buffer multi request for a list of actions.
576    * Propagates Actions original index.
577    *
578    * @param regionName
579    * @param actions
580    * @return a multi request
581    * @throws IOException
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    * Create a protocol buffer multirequest with NO data for a list of actions (data is carried
626    * otherwise than via protobuf).  This means it just notes attributes, whether to write the
627    * WAL, etc., and the presence in protobuf serves as place holder for the data which is
628    * coming along otherwise.  Note that Get is different.  It does not contain 'data' and is always
629    * carried by protobuf.  We return references to the data by adding them to the passed in
630    * <code>data</code> param.
631    *
632    * <p>Propagates Actions original index.
633    *
634    * @param regionName
635    * @param actions
636    * @param cells Place to stuff references to actual data.
637    * @return a multi request that does not carry any data.
638    * @throws IOException
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         // Note that a legitimate Delete may have a size of zero; i.e. a Delete that has nothing
664         // in it but the row to delete.  In this case, the current implementation does not make
665         // a KeyValue to represent a delete-of-all-the-row until we serialize... For such cases
666         // where the size returned is zero, we will send the Delete fully pb'd rather than have
667         // metadata only in the pb and then send the kv along the side in cells.
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; // ignore RowMutations
688       } else {
689         throw new DoNotRetryIOException("Multi doesn't support " + row.getClass().getName());
690       }
691     }
692     return builder;
693   }
694 
695 // End utilities for Client
696 //Start utilities for Admin
697 
698   /**
699    * Create a protocol buffer GetRegionInfoRequest for a given region name
700    *
701    * @param regionName the name of the region to get info
702    * @return a protocol buffer GetRegionInfoRequest
703    */
704   public static GetRegionInfoRequest
705       buildGetRegionInfoRequest(final byte[] regionName) {
706     return buildGetRegionInfoRequest(regionName, false);
707   }
708 
709   /**
710    * Create a protocol buffer GetRegionInfoRequest for a given region name
711    *
712    * @param regionName the name of the region to get info
713    * @param includeCompactionState indicate if the compaction state is requested
714    * @return a protocol buffer GetRegionInfoRequest
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   * Create a protocol buffer GetStoreFileRequest for a given region name
731   *
732   * @param regionName the name of the region to get info
733   * @param family the family to get store file list
734   * @return a protocol buffer GetStoreFileRequest
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   * Create a protocol buffer GetOnlineRegionRequest
748   *
749   * @return a protocol buffer GetOnlineRegionRequest
750   */
751  public static GetOnlineRegionRequest buildGetOnlineRegionRequest() {
752    return GetOnlineRegionRequest.newBuilder().build();
753  }
754 
755  /**
756   * Create a protocol buffer FlushRegionRequest for a given region name
757   *
758   * @param regionName the name of the region to get info
759   * @return a protocol buffer FlushRegionRequest
760   */
761  public static FlushRegionRequest
762      buildFlushRegionRequest(final byte[] regionName) {
763    return buildFlushRegionRequest(regionName, false);
764  }
765 
766  /**
767   * Create a protocol buffer FlushRegionRequest for a given region name
768   *
769   * @param regionName the name of the region to get info
770   * @return a protocol buffer FlushRegionRequest
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   * Create a protocol buffer OpenRegionRequest to open a list of regions
784   *
785   * @param server the serverName for the RPC
786   * @param regionOpenInfos info of a list of regions to open
787   * @param openForReplay
788   * @return a protocol buffer OpenRegionRequest
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    // send the master's wall clock time as well, so that the RS can refer to it
804    builder.setMasterSystemTime(EnvironmentEdgeManager.currentTime());
805    return builder.build();
806  }
807 
808  /**
809   * Create a protocol buffer OpenRegionRequest for a given region
810   *
811   * @param server the serverName for the RPC
812   * @param region the region to open
813   * @param versionOfOfflineNode that needs to be present in the offline node
814   * @param favoredNodes
815   * @param openForReplay
816   * @return a protocol buffer OpenRegionRequest
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   * Create a protocol buffer UpdateFavoredNodesRequest to update a list of favorednode mappings
833   * @param updateRegionInfos
834   * @return a protocol buffer UpdateFavoredNodesRequest
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   * Create a CloseRegionRequest for a given region name
852   *
853   * @param regionName the name of the region to close
854   * @param transitionInZK indicator if to transition in ZK
855   * @return a CloseRegionRequest
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    *  Create a WarmupRegionRequest for a given region name
890    *
891    *  @param regionInfo Region we are warming up
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   * Create a CloseRegionRequest for a given encoded region name
900   *
901   * @param encodedRegionName the name of the region to close
902   * @param transitionInZK indicator if to transition in ZK
903   * @return a CloseRegionRequest
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   * Create a SplitRegionRequest for a given region name
922   *
923   * @param regionName the name of the region to split
924   * @param splitPoint the split point
925   * @return a SplitRegionRequest
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    * Create a MergeRegionsRequest for the given regions
941    * @param regionA name of region a
942    * @param regionB name of region b
943    * @param forcible true if it is a compulsory merge
944    * @return a MergeRegionsRequest
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     // send the master's wall clock time as well, so that the RS can refer to it
957     builder.setMasterSystemTime(EnvironmentEdgeManager.currentTime());
958     return builder.build();
959   }
960 
961  /**
962   * Create a  CompactRegionRequest for a given region name
963   *
964   * @param regionName the name of the region to get info
965   * @param major indicator if it is a major compaction
966   * @return a CompactRegionRequest
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   * @see {@link #buildRollWALWriterRequest()
983   */
984  private static RollWALWriterRequest ROLL_WAL_WRITER_REQUEST =
985      RollWALWriterRequest.newBuilder().build();
986 
987   /**
988   * Create a new RollWALWriterRequest
989   *
990   * @return a ReplicateWALEntryRequest
991   */
992  public static RollWALWriterRequest buildRollWALWriterRequest() {
993    return ROLL_WAL_WRITER_REQUEST;
994  }
995 
996  /**
997   * @see {@link #buildGetServerInfoRequest()}
998   */
999  private static GetServerInfoRequest GET_SERVER_INFO_REQUEST =
1000    GetServerInfoRequest.newBuilder().build();
1001 
1002  /**
1003   * Create a new GetServerInfoRequest
1004   *
1005   * @return a GetServerInfoRequest
1006   */
1007  public static GetServerInfoRequest buildGetServerInfoRequest() {
1008    return GET_SERVER_INFO_REQUEST;
1009  }
1010 
1011  /**
1012   * Create a new StopServerRequest
1013   *
1014   * @param reason the reason to stop the server
1015   * @return a StopServerRequest
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 //End utilities for Admin
1024 
1025   /**
1026    * Convert a byte array to a protocol buffer RegionSpecifier
1027    *
1028    * @param type the region specifier type
1029    * @param value the region specifier byte array value
1030    * @return a protocol buffer RegionSpecifier
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    * Create a protocol buffer Condition
1042    *
1043    * @param row
1044    * @param family
1045    * @param qualifier
1046    * @param comparator
1047    * @param compareType
1048    * @return a Condition
1049    * @throws IOException
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    * Create a protocol buffer AddColumnRequest
1066    *
1067    * @param tableName
1068    * @param column
1069    * @return an AddColumnRequest
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    * Create a protocol buffer DeleteColumnRequest
1081    *
1082    * @param tableName
1083    * @param columnName
1084    * @return a DeleteColumnRequest
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    * Create a protocol buffer ModifyColumnRequest
1096    *
1097    * @param tableName
1098    * @param column
1099    * @return an ModifyColumnRequest
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    * Create a protocol buffer MoveRegionRequest
1111    *
1112    * @param encodedRegionName
1113    * @param destServerName
1114    * @return A MoveRegionRequest
1115    * @throws DeserializationException
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    * Create a protocol buffer AssignRegionRequest
1144    *
1145    * @param regionName
1146    * @return an AssignRegionRequest
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    * Creates a protocol buffer UnassignRegionRequest
1156    *
1157    * @param regionName
1158    * @param force
1159    * @return an UnassignRegionRequest
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    * Creates a protocol buffer OfflineRegionRequest
1171    *
1172    * @param regionName
1173    * @return an OfflineRegionRequest
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    * Creates a protocol buffer DeleteTableRequest
1183    *
1184    * @param tableName
1185    * @return a DeleteTableRequest
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    * Creates a protocol buffer TruncateTableRequest
1195    *
1196    * @param tableName name of table to truncate
1197    * @param preserveSplits True if the splits should be preserved
1198    * @return a TruncateTableRequest
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    * Creates a protocol buffer EnableTableRequest
1210    *
1211    * @param tableName
1212    * @return an EnableTableRequest
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    * Creates a protocol buffer DisableTableRequest
1222    *
1223    * @param tableName
1224    * @return a DisableTableRequest
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    * Creates a protocol buffer CreateTableRequest
1234    *
1235    * @param hTableDesc
1236    * @param splitKeys
1237    * @return a CreateTableRequest
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    * Creates a protocol buffer ModifyTableRequest
1254    *
1255    * @param tableName
1256    * @param hTableDesc
1257    * @return a ModifyTableRequest
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    * Creates a protocol buffer GetSchemaAlterStatusRequest
1285    *
1286    * @param tableName
1287    * @return a GetSchemaAlterStatusRequest
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    * Creates a protocol buffer GetTableDescriptorsRequest
1298    *
1299    * @param tableNames
1300    * @return a GetTableDescriptorsRequest
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    * Creates a protocol buffer GetTableDescriptorsRequest
1315    *
1316    * @param pattern The compiled regular expression to match against
1317    * @param includeSysTables False to match only against userspace tables
1318    * @return a GetTableDescriptorsRequest
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    * Creates a protocol buffer GetTableNamesRequest
1330    *
1331    * @param pattern The compiled regular expression to match against
1332    * @param includeSysTables False to match only against userspace tables
1333    * @return a GetTableNamesRequest
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    * Creates a protocol buffer GetTableDescriptorsRequest for a single table
1345    *
1346    * @param tableName the table name
1347    * @return a GetTableDescriptorsRequest
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    * Creates a protocol buffer IsMasterRunningRequest
1358    *
1359    * @return a IsMasterRunningRequest
1360    */
1361   public static IsMasterRunningRequest buildIsMasterRunningRequest() {
1362     return IsMasterRunningRequest.newBuilder().build();
1363   }
1364 
1365   /**
1366    * Creates a protocol buffer BalanceRequest
1367    *
1368    * @return a BalanceRequest
1369    */
1370   public static BalanceRequest buildBalanceRequest(boolean force) {
1371     return BalanceRequest.newBuilder().setForce(force).build();
1372   }
1373 
1374   /**
1375    * Creates a protocol buffer SetBalancerRunningRequest
1376    *
1377    * @param on
1378    * @param synchronous
1379    * @return a SetBalancerRunningRequest
1380    */
1381   public static SetBalancerRunningRequest buildSetBalancerRunningRequest(boolean on, boolean synchronous) {
1382     return SetBalancerRunningRequest.newBuilder().setOn(on).setSynchronous(synchronous).build();
1383   }
1384 
1385   /**
1386    * Creates a protocol buffer IsBalancerEnabledRequest
1387    *
1388    * @return a IsBalancerEnabledRequest
1389    */
1390   public static IsBalancerEnabledRequest buildIsBalancerEnabledRequest() {
1391     return IsBalancerEnabledRequest.newBuilder().build();
1392   }
1393 
1394   /**
1395    * @see {@link #buildGetClusterStatusRequest}
1396    */
1397   private static final GetClusterStatusRequest GET_CLUSTER_STATUS_REQUEST =
1398       GetClusterStatusRequest.newBuilder().build();
1399 
1400   /**
1401    * Creates a protocol buffer GetClusterStatusRequest
1402    *
1403    * @return A GetClusterStatusRequest
1404    */
1405   public static GetClusterStatusRequest buildGetClusterStatusRequest() {
1406     return GET_CLUSTER_STATUS_REQUEST;
1407   }
1408 
1409   /**
1410    * @see {@link #buildCatalogScanRequest}
1411    */
1412   private static final RunCatalogScanRequest CATALOG_SCAN_REQUEST =
1413     RunCatalogScanRequest.newBuilder().build();
1414 
1415   /**
1416    * Creates a request for running a catalog scan
1417    * @return A {@link RunCatalogScanRequest}
1418    */
1419   public static RunCatalogScanRequest buildCatalogScanRequest() {
1420     return CATALOG_SCAN_REQUEST;
1421   }
1422 
1423   /**
1424    * Creates a request for enabling/disabling the catalog janitor
1425    * @return A {@link EnableCatalogJanitorRequest}
1426    */
1427   public static EnableCatalogJanitorRequest buildEnableCatalogJanitorRequest(boolean enable) {
1428     return EnableCatalogJanitorRequest.newBuilder().setEnable(enable).build();
1429   }
1430 
1431   /**
1432    * @see {@link #buildIsCatalogJanitorEnabledRequest()}
1433    */
1434   private static final IsCatalogJanitorEnabledRequest IS_CATALOG_JANITOR_ENABLED_REQUEST =
1435     IsCatalogJanitorEnabledRequest.newBuilder().build();
1436 
1437   /**
1438    * Creates a request for querying the master whether the catalog janitor is enabled
1439    * @return A {@link IsCatalogJanitorEnabledRequest}
1440    */
1441   public static IsCatalogJanitorEnabledRequest buildIsCatalogJanitorEnabledRequest() {
1442     return IS_CATALOG_JANITOR_ENABLED_REQUEST;
1443   }
1444 
1445   /**
1446    * Creates a request for querying the master the last flushed sequence Id for a region
1447    * @param regionName
1448    * @return A {@link GetLastFlushedSequenceIdRequest}
1449    */
1450   public static GetLastFlushedSequenceIdRequest buildGetLastFlushedSequenceIdRequest(
1451       byte[] regionName) {
1452     return GetLastFlushedSequenceIdRequest.newBuilder().setRegionName(
1453         ByteStringer.wrap(regionName)).build();
1454   }
1455 
1456   /**
1457    * Create a request to grant user permissions.
1458    *
1459    * @param username the short user name who to grant permissions
1460    * @param actions the permissions to be granted
1461    * @return A {@link AccessControlProtos} GrantRequest
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    * Create a request to grant user permissions.
1484    *
1485    * @param username the short user name who to grant permissions
1486    * @param tableName optional table name the permissions apply
1487    * @param family optional column family
1488    * @param qualifier optional qualifier
1489    * @param actions the permissions to be granted
1490    * @return A {@link AccessControlProtos} GrantRequest
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    * Create a request to grant user permissions.
1525    *
1526    * @param username the short user name who to grant permissions
1527    * @param namespace optional table name the permissions apply
1528    * @param actions the permissions to be granted
1529    * @return A {@link AccessControlProtos} GrantRequest
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    * Create a request to revoke user permissions.
1556    *
1557    * @param username the short user name whose permissions to be revoked
1558    * @param actions the permissions to be revoked
1559    * @return A {@link AccessControlProtos} RevokeRequest
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    * Create a request to revoke user permissions.
1582    *
1583    * @param username the short user name whose permissions to be revoked
1584    * @param tableName optional table name the permissions apply
1585    * @param family optional column family
1586    * @param qualifier optional qualifier
1587    * @param actions the permissions to be revoked
1588    * @return A {@link AccessControlProtos} RevokeRequest
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    * Create a request to revoke user permissions.
1621    *
1622    * @param username the short user name whose permissions to be revoked
1623    * @param namespace optional table name the permissions apply
1624    * @param actions the permissions to be revoked
1625    * @return A {@link AccessControlProtos} RevokeRequest
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    * Create a RegionOpenInfo based on given region info and version of offline node
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    * Creates a protocol buffer NormalizeRequest
1674    *
1675    * @return a NormalizeRequest
1676    */
1677   public static NormalizeRequest buildNormalizeRequest() {
1678     return NormalizeRequest.newBuilder().build();
1679   }
1680 
1681   /**
1682    * Creates a protocol buffer IsNormalizerEnabledRequest
1683    *
1684    * @return a IsNormalizerEnabledRequest
1685    */
1686   public static IsNormalizerEnabledRequest buildIsNormalizerEnabledRequest() {
1687     return IsNormalizerEnabledRequest.newBuilder().build();
1688   }
1689 
1690   /**
1691    * Creates a protocol buffer SetNormalizerRunningRequest
1692    *
1693    * @param on
1694    * @return a SetNormalizerRunningRequest
1695    */
1696   public static SetNormalizerRunningRequest buildSetNormalizerRunningRequest(boolean on) {
1697     return SetNormalizerRunningRequest.newBuilder().setOn(on).build();
1698   }
1699 
1700   /**
1701    * Creates a protocol buffer IsSplitOrMergeEnabledRequest
1702    *
1703    * @param switchType see {@link org.apache.hadoop.hbase.client.Admin.MasterSwitchType}
1704    * @return a IsSplitOrMergeEnabledRequest
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    * Creates a protocol buffer SetSplitOrMergeEnabledRequest
1715    *
1716    * @param enabled switch is enabled or not
1717    * @param synchronous set switch sync?
1718    * @param switchTypes see {@link org.apache.hadoop.hbase.client.Admin.MasterSwitchType}, it is
1719    *                    a list.
1720    * @return a SetSplitOrMergeEnabledRequest
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 }