001/* 002 * Licensed to the Apache Software Foundation (ASF) under one 003 * or more contributor license agreements. See the NOTICE file 004 * distributed with this work for additional information 005 * regarding copyright ownership. The ASF licenses this file 006 * to you under the Apache License, Version 2.0 (the 007 * "License"); you may not use this file except in compliance 008 * with the License. You may obtain a copy of the License at 009 * 010 * http://www.apache.org/licenses/LICENSE-2.0 011 * 012 * Unless required by applicable law or agreed to in writing, software 013 * distributed under the License is distributed on an "AS IS" BASIS, 014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 015 * See the License for the specific language governing permissions and 016 * limitations under the License. 017 */ 018package org.apache.hadoop.hbase.shaded.protobuf; 019 020import java.io.IOException; 021import java.util.ArrayList; 022import java.util.Collection; 023import java.util.EnumSet; 024import java.util.List; 025import java.util.Map; 026import java.util.Set; 027import java.util.regex.Pattern; 028import java.util.stream.Collectors; 029import org.apache.commons.lang3.StringUtils; 030import org.apache.hadoop.hbase.ClusterMetrics.Option; 031import org.apache.hadoop.hbase.ClusterMetricsBuilder; 032import org.apache.hadoop.hbase.CompareOperator; 033import org.apache.hadoop.hbase.DoNotRetryIOException; 034import org.apache.hadoop.hbase.ExtendedCellScannable; 035import org.apache.hadoop.hbase.HConstants; 036import org.apache.hadoop.hbase.NamespaceDescriptor; 037import org.apache.hadoop.hbase.ServerName; 038import org.apache.hadoop.hbase.TableName; 039import org.apache.hadoop.hbase.client.Action; 040import org.apache.hadoop.hbase.client.Append; 041import org.apache.hadoop.hbase.client.CheckAndMutate; 042import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; 043import org.apache.hadoop.hbase.client.Delete; 044import org.apache.hadoop.hbase.client.Get; 045import org.apache.hadoop.hbase.client.Increment; 046import org.apache.hadoop.hbase.client.MasterSwitchType; 047import org.apache.hadoop.hbase.client.Mutation; 048import org.apache.hadoop.hbase.client.NormalizeTableFilterParams; 049import org.apache.hadoop.hbase.client.Put; 050import org.apache.hadoop.hbase.client.RegionCoprocessorServiceExec; 051import org.apache.hadoop.hbase.client.RegionInfo; 052import org.apache.hadoop.hbase.client.Row; 053import org.apache.hadoop.hbase.client.RowMutations; 054import org.apache.hadoop.hbase.client.Scan; 055import org.apache.hadoop.hbase.client.TableDescriptor; 056import org.apache.hadoop.hbase.client.TableState; 057import org.apache.hadoop.hbase.client.replication.ReplicationPeerConfigUtil; 058import org.apache.hadoop.hbase.exceptions.DeserializationException; 059import org.apache.hadoop.hbase.filter.Filter; 060import org.apache.hadoop.hbase.io.TimeRange; 061import org.apache.hadoop.hbase.master.RegionState; 062import org.apache.hadoop.hbase.net.Address; 063import org.apache.hadoop.hbase.replication.ReplicationPeerConfig; 064import org.apache.hadoop.hbase.replication.SyncReplicationState; 065import org.apache.hadoop.hbase.util.Bytes; 066import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; 067import org.apache.hadoop.hbase.util.Pair; 068import org.apache.hadoop.security.token.Token; 069import org.apache.yetus.audience.InterfaceAudience; 070 071import org.apache.hbase.thirdparty.com.google.common.collect.Sets; 072import org.apache.hbase.thirdparty.com.google.protobuf.ByteString; 073import org.apache.hbase.thirdparty.com.google.protobuf.UnsafeByteOperations; 074import org.apache.hbase.thirdparty.org.apache.commons.collections4.MapUtils; 075 076import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.ClearCompactionQueuesRequest; 077import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.ClearRegionBlockCacheRequest; 078import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.ClearSlowLogResponseRequest; 079import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.CompactRegionRequest; 080import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.FlushRegionRequest; 081import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetOnlineRegionRequest; 082import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionInfoRequest; 083import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionLoadRequest; 084import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetServerInfoRequest; 085import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.OpenRegionRequest; 086import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.OpenRegionRequest.RegionOpenInfo; 087import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.RollWALWriterRequest; 088import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.SlowLogResponseRequest; 089import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.StopServerRequest; 090import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.UpdateFavoredNodesRequest; 091import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.UpdateFavoredNodesRequest.RegionUpdateInfo; 092import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.WarmupRegionRequest; 093import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos; 094import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.BulkLoadHFileRequest; 095import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.Condition; 096import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.GetRequest; 097import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MultiRequest; 098import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutateRequest; 099import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutationProto; 100import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.MutationProto.MutationType; 101import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.RegionAction; 102import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ScanRequest; 103import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos; 104import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.RegionSpecifier; 105import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.RegionSpecifier.RegionSpecifierType; 106import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos; 107import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.AddColumnRequest; 108import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.AssignRegionRequest; 109import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.ClearDeadServersRequest; 110import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.CreateNamespaceRequest; 111import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.CreateTableRequest; 112import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.DecommissionRegionServersRequest; 113import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.DeleteColumnRequest; 114import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.DeleteNamespaceRequest; 115import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.DeleteTableRequest; 116import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.DisableTableRequest; 117import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.EnableCatalogJanitorRequest; 118import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.EnableTableRequest; 119import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.FlushTableRequest; 120import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetClusterStatusRequest; 121import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetNamespaceDescriptorRequest; 122import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetTableDescriptorsRequest; 123import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetTableNamesRequest; 124import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.IsBalancerEnabledRequest; 125import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.IsCatalogJanitorEnabledRequest; 126import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.IsCleanerChoreEnabledRequest; 127import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.IsMasterRunningRequest; 128import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.IsNormalizerEnabledRequest; 129import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.IsSnapshotCleanupEnabledRequest; 130import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.IsSplitOrMergeEnabledRequest; 131import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.MergeTableRegionsRequest; 132import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.ModifyColumnRequest; 133import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.ModifyColumnStoreFileTrackerRequest; 134import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.ModifyNamespaceRequest; 135import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.ModifyTableRequest; 136import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.ModifyTableStoreFileTrackerRequest; 137import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.MoveRegionRequest; 138import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.NormalizeRequest; 139import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.OfflineRegionRequest; 140import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.RecommissionRegionServerRequest; 141import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.RegionSpecifierAndState; 142import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.ReopenTableRegionsRequest; 143import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.RollAllWALWritersRequest; 144import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.RunCatalogScanRequest; 145import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.RunCleanerChoreRequest; 146import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.SetBalancerRunningRequest; 147import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.SetCleanerChoreRunningRequest; 148import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.SetNormalizerRunningRequest; 149import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.SetRegionStateInMetaRequest; 150import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.SetSnapshotCleanupRequest; 151import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.SetSplitOrMergeEnabledRequest; 152import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.SetTableStateInMetaRequest; 153import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.SplitTableRegionRequest; 154import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.TruncateTableRequest; 155import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.UnassignRegionRequest; 156import org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.GetQuotaStatesRequest; 157import org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.GetSpaceQuotaRegionSizesRequest; 158import org.apache.hadoop.hbase.shaded.protobuf.generated.QuotaProtos.GetSpaceQuotaSnapshotsRequest; 159import org.apache.hadoop.hbase.shaded.protobuf.generated.RSGroupAdminProtos.MoveServersRequest; 160import org.apache.hadoop.hbase.shaded.protobuf.generated.RSGroupAdminProtos.RemoveServersRequest; 161import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.GetLastFlushedSequenceIdRequest; 162import org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos; 163import org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos.AddReplicationPeerRequest; 164import org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos.DisableReplicationPeerRequest; 165import org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos.EnableReplicationPeerRequest; 166import org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos.GetReplicationPeerConfigRequest; 167import org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos.ListReplicationPeersRequest; 168import org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos.RemoveReplicationPeerRequest; 169import org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos.TransitReplicationPeerSyncReplicationStateRequest; 170import org.apache.hadoop.hbase.shaded.protobuf.generated.ReplicationProtos.UpdateReplicationPeerConfigRequest; 171 172/** 173 * Helper utility to build protocol buffer requests, or build components for protocol buffer 174 * requests. 175 */ 176@InterfaceAudience.Private 177public final class RequestConverter { 178 179 private RequestConverter() { 180 } 181 182 // Start utilities for Client 183 184 /** 185 * Create a protocol buffer GetRequest for a client Get 186 * @param regionName the name of the region to get 187 * @param get the client Get 188 * @return a protocol buffer GetRequest 189 */ 190 public static GetRequest buildGetRequest(final byte[] regionName, final Get get) 191 throws IOException { 192 GetRequest.Builder builder = GetRequest.newBuilder(); 193 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 194 builder.setRegion(region); 195 builder.setGet(ProtobufUtil.toGet(get)); 196 return builder.build(); 197 } 198 199 /** 200 * Create a protocol buffer MutateRequest for a conditioned put/delete/increment/append 201 * @return a mutate request 202 */ 203 public static MutateRequest buildMutateRequest(final byte[] regionName, final byte[] row, 204 final byte[] family, final byte[] qualifier, final CompareOperator op, final byte[] value, 205 final Filter filter, final TimeRange timeRange, final Mutation mutation, long nonceGroup, 206 long nonce, boolean queryMetricsEnabled) throws IOException { 207 MutateRequest.Builder builder = MutateRequest.newBuilder(); 208 if (mutation instanceof Increment || mutation instanceof Append) { 209 builder.setMutation(ProtobufUtil.toMutation(getMutationType(mutation), mutation, nonce)) 210 .setNonceGroup(nonceGroup); 211 } else { 212 builder.setMutation(ProtobufUtil.toMutation(getMutationType(mutation), mutation)); 213 } 214 return builder.setRegion(buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName)) 215 .setCondition(ProtobufUtil.toCondition(row, family, qualifier, op, value, filter, timeRange, 216 queryMetricsEnabled)) 217 .build(); 218 } 219 220 /** 221 * Create a protocol buffer MultiRequest for conditioned row mutations 222 * @return a multi request 223 */ 224 public static ClientProtos.MultiRequest buildMultiRequest(final byte[] regionName, 225 final byte[] row, final byte[] family, final byte[] qualifier, final CompareOperator op, 226 final byte[] value, final Filter filter, final TimeRange timeRange, 227 final RowMutations rowMutations, long nonceGroup, long nonce, boolean queryMetricsEnabled) 228 throws IOException { 229 return buildMultiRequest(regionName, rowMutations, ProtobufUtil.toCondition(row, family, 230 qualifier, op, value, filter, timeRange, queryMetricsEnabled), nonceGroup, nonce); 231 } 232 233 /** 234 * Create a protocol buffer MultiRequest for row mutations 235 * @return a multi request 236 */ 237 public static ClientProtos.MultiRequest buildMultiRequest(final byte[] regionName, 238 final RowMutations rowMutations, long nonceGroup, long nonce) throws IOException { 239 return buildMultiRequest(regionName, rowMutations, null, nonceGroup, nonce); 240 } 241 242 private static ClientProtos.MultiRequest buildMultiRequest(final byte[] regionName, 243 final RowMutations rowMutations, final Condition condition, long nonceGroup, long nonce) 244 throws IOException { 245 RegionAction.Builder builder = 246 getRegionActionBuilderWithRegion(RegionAction.newBuilder(), regionName); 247 builder.setAtomic(true); 248 249 boolean hasNonce = false; 250 ClientProtos.Action.Builder actionBuilder = ClientProtos.Action.newBuilder(); 251 MutationProto.Builder mutationBuilder = MutationProto.newBuilder(); 252 for (Mutation mutation : rowMutations.getMutations()) { 253 mutationBuilder.clear(); 254 MutationProto mp; 255 if (mutation instanceof Increment || mutation instanceof Append) { 256 mp = ProtobufUtil.toMutation(getMutationType(mutation), mutation, mutationBuilder, nonce); 257 hasNonce = true; 258 } else { 259 mp = ProtobufUtil.toMutation(getMutationType(mutation), mutation, mutationBuilder); 260 } 261 actionBuilder.clear(); 262 actionBuilder.setMutation(mp); 263 builder.addAction(actionBuilder.build()); 264 } 265 266 if (condition != null) { 267 builder.setCondition(condition); 268 } 269 270 MultiRequest.Builder multiRequestBuilder = MultiRequest.newBuilder(); 271 if (hasNonce) { 272 multiRequestBuilder.setNonceGroup(nonceGroup); 273 } 274 275 return multiRequestBuilder.addRegionAction(builder.build()).build(); 276 } 277 278 /** 279 * Create a protocol buffer MutateRequest for a put 280 * @return a mutate request 281 */ 282 public static MutateRequest buildMutateRequest(final byte[] regionName, final Put put) 283 throws IOException { 284 MutateRequest.Builder builder = MutateRequest.newBuilder(); 285 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 286 builder.setRegion(region); 287 builder.setMutation(ProtobufUtil.toMutation(MutationType.PUT, put, MutationProto.newBuilder())); 288 return builder.build(); 289 } 290 291 /** 292 * Create a protocol buffer MutateRequest for an append 293 * @return a mutate request 294 */ 295 public static MutateRequest buildMutateRequest(final byte[] regionName, final Append append, 296 long nonceGroup, long nonce) throws IOException { 297 MutateRequest.Builder builder = MutateRequest.newBuilder(); 298 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 299 builder.setRegion(region); 300 if (nonce != HConstants.NO_NONCE && nonceGroup != HConstants.NO_NONCE) { 301 builder.setNonceGroup(nonceGroup); 302 } 303 builder.setMutation( 304 ProtobufUtil.toMutation(MutationType.APPEND, append, MutationProto.newBuilder(), nonce)); 305 return builder.build(); 306 } 307 308 /** 309 * Create a protocol buffer MutateRequest for a client increment 310 * @return a mutate request 311 */ 312 public static MutateRequest buildMutateRequest(final byte[] regionName, final Increment increment, 313 final long nonceGroup, final long nonce) throws IOException { 314 MutateRequest.Builder builder = MutateRequest.newBuilder(); 315 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 316 builder.setRegion(region); 317 if (nonce != HConstants.NO_NONCE && nonceGroup != HConstants.NO_NONCE) { 318 builder.setNonceGroup(nonceGroup); 319 } 320 builder.setMutation(ProtobufUtil.toMutation(MutationType.INCREMENT, increment, 321 MutationProto.newBuilder(), nonce)); 322 return builder.build(); 323 } 324 325 /** 326 * Create a protocol buffer MutateRequest for a delete 327 * @return a mutate request 328 */ 329 public static MutateRequest buildMutateRequest(final byte[] regionName, final Delete delete) 330 throws IOException { 331 MutateRequest.Builder builder = MutateRequest.newBuilder(); 332 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 333 builder.setRegion(region); 334 builder.setMutation( 335 ProtobufUtil.toMutation(MutationType.DELETE, delete, MutationProto.newBuilder())); 336 return builder.build(); 337 } 338 339 public static RegionAction.Builder getRegionActionBuilderWithRegion( 340 final RegionAction.Builder regionActionBuilder, final byte[] regionName) { 341 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 342 regionActionBuilder.setRegion(region); 343 return regionActionBuilder; 344 } 345 346 /** 347 * Create a protocol buffer ScanRequest for a client Scan 348 * @return a scan request 349 */ 350 public static ScanRequest buildScanRequest(byte[] regionName, Scan scan, int numberOfRows, 351 boolean closeScanner) throws IOException { 352 ScanRequest.Builder builder = ScanRequest.newBuilder(); 353 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 354 builder.setNumberOfRows(numberOfRows); 355 builder.setCloseScanner(closeScanner); 356 builder.setRegion(region); 357 builder.setScan(ProtobufUtil.toScan(scan)); 358 builder.setClientHandlesPartials(true); 359 builder.setClientHandlesHeartbeats(true); 360 builder.setTrackScanMetrics(scan.isScanMetricsEnabled()); 361 if (scan.getLimit() > 0) { 362 builder.setLimitOfRows(scan.getLimit()); 363 } 364 return builder.build(); 365 } 366 367 /** 368 * Create a protocol buffer ScanRequest for a scanner id 369 * @return a scan request 370 */ 371 public static ScanRequest buildScanRequest(long scannerId, int numberOfRows, boolean closeScanner, 372 boolean trackMetrics) { 373 ScanRequest.Builder builder = ScanRequest.newBuilder(); 374 builder.setNumberOfRows(numberOfRows); 375 builder.setCloseScanner(closeScanner); 376 builder.setScannerId(scannerId); 377 builder.setClientHandlesPartials(true); 378 builder.setClientHandlesHeartbeats(true); 379 builder.setTrackScanMetrics(trackMetrics); 380 return builder.build(); 381 } 382 383 /** 384 * Create a protocol buffer ScanRequest for a scanner id 385 * @return a scan request 386 */ 387 public static ScanRequest buildScanRequest(long scannerId, int numberOfRows, boolean closeScanner, 388 long nextCallSeq, boolean trackMetrics, boolean renew, int limitOfRows) { 389 ScanRequest.Builder builder = ScanRequest.newBuilder(); 390 builder.setNumberOfRows(numberOfRows); 391 builder.setCloseScanner(closeScanner); 392 builder.setScannerId(scannerId); 393 builder.setNextCallSeq(nextCallSeq); 394 builder.setClientHandlesPartials(true); 395 builder.setClientHandlesHeartbeats(true); 396 builder.setTrackScanMetrics(trackMetrics); 397 builder.setRenew(renew); 398 if (limitOfRows > 0) { 399 builder.setLimitOfRows(limitOfRows); 400 } 401 return builder.build(); 402 } 403 404 /** 405 * Create a protocol buffer bulk load request 406 * @return a bulk load request 407 */ 408 public static BulkLoadHFileRequest buildBulkLoadHFileRequest( 409 final List<Pair<byte[], String>> familyPaths, final byte[] regionName, boolean assignSeqNum, 410 final Token<?> userToken, final String bulkToken, boolean copyFiles, List<String> clusterIds, 411 boolean replicate) { 412 RegionSpecifier region = 413 RequestConverter.buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 414 415 ClientProtos.DelegationToken protoDT = null; 416 if (userToken != null) { 417 protoDT = ClientProtos.DelegationToken.newBuilder() 418 .setIdentifier(UnsafeByteOperations.unsafeWrap(userToken.getIdentifier())) 419 .setPassword(UnsafeByteOperations.unsafeWrap(userToken.getPassword())) 420 .setKind(userToken.getKind().toString()).setService(userToken.getService().toString()) 421 .build(); 422 } 423 424 List<ClientProtos.BulkLoadHFileRequest.FamilyPath> protoFamilyPaths = 425 new ArrayList<>(familyPaths.size()); 426 if (!familyPaths.isEmpty()) { 427 ClientProtos.BulkLoadHFileRequest.FamilyPath.Builder pathBuilder = 428 ClientProtos.BulkLoadHFileRequest.FamilyPath.newBuilder(); 429 for (Pair<byte[], String> el : familyPaths) { 430 protoFamilyPaths.add(pathBuilder.setFamily(UnsafeByteOperations.unsafeWrap(el.getFirst())) 431 .setPath(el.getSecond()).build()); 432 } 433 pathBuilder.clear(); 434 } 435 436 BulkLoadHFileRequest.Builder request = ClientProtos.BulkLoadHFileRequest.newBuilder() 437 .setRegion(region).setAssignSeqNum(assignSeqNum).addAllFamilyPath(protoFamilyPaths); 438 if (userToken != null) { 439 request.setFsToken(protoDT); 440 } 441 if (bulkToken != null) { 442 request.setBulkToken(bulkToken); 443 } 444 request.setCopyFile(copyFiles); 445 if (clusterIds != null) { 446 request.addAllClusterIds(clusterIds); 447 } 448 request.setReplicate(replicate); 449 return request.build(); 450 } 451 452 /** 453 * Create a protocol buffer multirequest with NO data for a list of actions (data is carried 454 * otherwise than via protobuf). This means it just notes attributes, whether to write the WAL, 455 * etc., and the presence in protobuf serves as place holder for the data which is coming along 456 * otherwise. Note that Get is different. It does not contain 'data' and is always carried by 457 * protobuf. We return references to the data by adding them to the passed in <code>data</code> 458 * param. 459 * <p> 460 * Propagates Actions original index. 461 * <p> 462 * The passed in multiRequestBuilder will be populated with region actions. 463 * @param regionName The region name of the actions. 464 * @param actions The actions that are grouped by the same region name. 465 * @param cells Place to stuff references to actual data. 466 * @param multiRequestBuilder The multiRequestBuilder to be populated with region actions. 467 * @param regionActionBuilder regionActionBuilder to be used to build region action. 468 * @param actionBuilder actionBuilder to be used to build action. 469 * @param mutationBuilder mutationBuilder to be used to build mutation. 470 * @param nonceGroup nonceGroup to be applied. 471 * @param indexMap Map of created RegionAction to the original index for a 472 * RowMutations/CheckAndMutate within the original list of actions 473 */ 474 public static void buildNoDataRegionActions(final byte[] regionName, 475 final Iterable<Action> actions, final List<ExtendedCellScannable> cells, 476 final MultiRequest.Builder multiRequestBuilder, final RegionAction.Builder regionActionBuilder, 477 final ClientProtos.Action.Builder actionBuilder, final MutationProto.Builder mutationBuilder, 478 long nonceGroup, final Map<Integer, Integer> indexMap) throws IOException { 479 regionActionBuilder.clear(); 480 RegionAction.Builder builder = 481 getRegionActionBuilderWithRegion(regionActionBuilder, regionName); 482 ClientProtos.CoprocessorServiceCall.Builder cpBuilder = null; 483 boolean hasNonce = false; 484 List<Action> rowMutationsList = new ArrayList<>(); 485 List<Action> checkAndMutates = new ArrayList<>(); 486 487 for (Action action : actions) { 488 Row row = action.getAction(); 489 actionBuilder.clear(); 490 actionBuilder.setIndex(action.getOriginalIndex()); 491 mutationBuilder.clear(); 492 if (row instanceof Get) { 493 Get g = (Get) row; 494 builder.addAction(actionBuilder.setGet(ProtobufUtil.toGet(g))); 495 } else if (row instanceof Put) { 496 buildNoDataRegionAction((Put) row, cells, builder, actionBuilder, mutationBuilder); 497 } else if (row instanceof Delete) { 498 buildNoDataRegionAction((Delete) row, cells, builder, actionBuilder, mutationBuilder); 499 } else if (row instanceof Append) { 500 buildNoDataRegionAction((Append) row, cells, action.getNonce(), builder, actionBuilder, 501 mutationBuilder); 502 hasNonce = true; 503 } else if (row instanceof Increment) { 504 buildNoDataRegionAction((Increment) row, cells, action.getNonce(), builder, actionBuilder, 505 mutationBuilder); 506 hasNonce = true; 507 } else if (row instanceof RegionCoprocessorServiceExec) { 508 RegionCoprocessorServiceExec exec = (RegionCoprocessorServiceExec) row; 509 // DUMB COPY!!! FIX!!! Done to copy from c.g.p.ByteString to shaded ByteString. 510 org.apache.hbase.thirdparty.com.google.protobuf.ByteString value = 511 org.apache.hbase.thirdparty.com.google.protobuf.UnsafeByteOperations 512 .unsafeWrap(exec.getRequest().toByteArray()); 513 if (cpBuilder == null) { 514 cpBuilder = ClientProtos.CoprocessorServiceCall.newBuilder(); 515 } else { 516 cpBuilder.clear(); 517 } 518 builder.addAction(actionBuilder 519 .setServiceCall(cpBuilder.setRow(UnsafeByteOperations.unsafeWrap(exec.getRow())) 520 .setServiceName(exec.getMethod().getService().getFullName()) 521 .setMethodName(exec.getMethod().getName()).setRequest(value))); 522 } else if (row instanceof RowMutations) { 523 rowMutationsList.add(action); 524 } else if (row instanceof CheckAndMutate) { 525 checkAndMutates.add(action); 526 } else { 527 throw new DoNotRetryIOException("Multi doesn't support " + row.getClass().getName()); 528 } 529 } 530 if (builder.getActionCount() > 0) { 531 multiRequestBuilder.addRegionAction(builder.build()); 532 } 533 534 // Process RowMutations here. We can not process it in the big loop above because 535 // it will corrupt the sequence order maintained in cells. 536 // RowMutations is a set of Puts and/or Deletes all to be applied atomically 537 // on the one row. We do separate RegionAction for each RowMutations. 538 // We maintain a map to keep track of this RegionAction and the original Action index. 539 for (Action action : rowMutationsList) { 540 builder.clear(); 541 getRegionActionBuilderWithRegion(builder, regionName); 542 543 boolean hasIncrementOrAppend = buildNoDataRegionAction((RowMutations) action.getAction(), 544 cells, action.getNonce(), builder, actionBuilder, mutationBuilder); 545 if (hasIncrementOrAppend) { 546 hasNonce = true; 547 } 548 builder.setAtomic(true); 549 550 multiRequestBuilder.addRegionAction(builder.build()); 551 552 // This rowMutations region action is at (multiRequestBuilder.getRegionActionCount() - 1) 553 // in the overall multiRequest. 554 indexMap.put(multiRequestBuilder.getRegionActionCount() - 1, action.getOriginalIndex()); 555 } 556 557 // Process CheckAndMutate here. Similar to RowMutations, we do separate RegionAction for each 558 // CheckAndMutate and maintain a map to keep track of this RegionAction and the original 559 // Action index. 560 for (Action action : checkAndMutates) { 561 builder.clear(); 562 getRegionActionBuilderWithRegion(builder, regionName); 563 564 CheckAndMutate cam = (CheckAndMutate) action.getAction(); 565 builder.setCondition(ProtobufUtil.toCondition(cam.getRow(), cam.getFamily(), 566 cam.getQualifier(), cam.getCompareOp(), cam.getValue(), cam.getFilter(), cam.getTimeRange(), 567 cam.isQueryMetricsEnabled())); 568 569 if (cam.getAction() instanceof Put) { 570 actionBuilder.clear(); 571 mutationBuilder.clear(); 572 buildNoDataRegionAction((Put) cam.getAction(), cells, builder, actionBuilder, 573 mutationBuilder); 574 } else if (cam.getAction() instanceof Delete) { 575 actionBuilder.clear(); 576 mutationBuilder.clear(); 577 buildNoDataRegionAction((Delete) cam.getAction(), cells, builder, actionBuilder, 578 mutationBuilder); 579 } else if (cam.getAction() instanceof Increment) { 580 actionBuilder.clear(); 581 mutationBuilder.clear(); 582 buildNoDataRegionAction((Increment) cam.getAction(), cells, action.getNonce(), builder, 583 actionBuilder, mutationBuilder); 584 hasNonce = true; 585 } else if (cam.getAction() instanceof Append) { 586 actionBuilder.clear(); 587 mutationBuilder.clear(); 588 buildNoDataRegionAction((Append) cam.getAction(), cells, action.getNonce(), builder, 589 actionBuilder, mutationBuilder); 590 hasNonce = true; 591 } else if (cam.getAction() instanceof RowMutations) { 592 boolean hasIncrementOrAppend = buildNoDataRegionAction((RowMutations) cam.getAction(), 593 cells, action.getNonce(), builder, actionBuilder, mutationBuilder); 594 if (hasIncrementOrAppend) { 595 hasNonce = true; 596 } 597 builder.setAtomic(true); 598 } else { 599 throw new DoNotRetryIOException( 600 "CheckAndMutate doesn't support " + cam.getAction().getClass().getName()); 601 } 602 603 multiRequestBuilder.addRegionAction(builder.build()); 604 605 // This CheckAndMutate region action is at (multiRequestBuilder.getRegionActionCount() - 1) 606 // in the overall multiRequest. 607 indexMap.put(multiRequestBuilder.getRegionActionCount() - 1, action.getOriginalIndex()); 608 } 609 610 if (!multiRequestBuilder.hasNonceGroup() && hasNonce) { 611 multiRequestBuilder.setNonceGroup(nonceGroup); 612 } 613 } 614 615 private static void buildNoDataRegionAction(final Put put, 616 final List<ExtendedCellScannable> cells, final RegionAction.Builder regionActionBuilder, 617 final ClientProtos.Action.Builder actionBuilder, final MutationProto.Builder mutationBuilder) 618 throws IOException { 619 cells.add(put); 620 regionActionBuilder.addAction(actionBuilder 621 .setMutation(ProtobufUtil.toMutationNoData(MutationType.PUT, put, mutationBuilder))); 622 } 623 624 private static void buildNoDataRegionAction(final Delete delete, 625 final List<ExtendedCellScannable> cells, final RegionAction.Builder regionActionBuilder, 626 final ClientProtos.Action.Builder actionBuilder, final MutationProto.Builder mutationBuilder) 627 throws IOException { 628 int size = delete.size(); 629 // Note that a legitimate Delete may have a size of zero; i.e. a Delete that has nothing 630 // in it but the row to delete. In this case, the current implementation does not make 631 // a KeyValue to represent a delete-of-all-the-row until we serialize... For such cases 632 // where the size returned is zero, we will send the Delete fully pb'd rather than have 633 // metadata only in the pb and then send the kv along the side in cells. 634 if (size > 0) { 635 cells.add(delete); 636 regionActionBuilder.addAction(actionBuilder 637 .setMutation(ProtobufUtil.toMutationNoData(MutationType.DELETE, delete, mutationBuilder))); 638 } else { 639 regionActionBuilder.addAction(actionBuilder 640 .setMutation(ProtobufUtil.toMutation(MutationType.DELETE, delete, mutationBuilder))); 641 } 642 } 643 644 private static void buildNoDataRegionAction(final Increment increment, 645 final List<ExtendedCellScannable> cells, long nonce, 646 final RegionAction.Builder regionActionBuilder, final ClientProtos.Action.Builder actionBuilder, 647 final MutationProto.Builder mutationBuilder) throws IOException { 648 cells.add(increment); 649 regionActionBuilder.addAction(actionBuilder.setMutation( 650 ProtobufUtil.toMutationNoData(MutationType.INCREMENT, increment, mutationBuilder, nonce))); 651 } 652 653 private static void buildNoDataRegionAction(final Append append, 654 final List<ExtendedCellScannable> cells, long nonce, 655 final RegionAction.Builder regionActionBuilder, final ClientProtos.Action.Builder actionBuilder, 656 final MutationProto.Builder mutationBuilder) throws IOException { 657 cells.add(append); 658 regionActionBuilder.addAction(actionBuilder.setMutation( 659 ProtobufUtil.toMutationNoData(MutationType.APPEND, append, mutationBuilder, nonce))); 660 } 661 662 /** Returns whether or not the rowMutations has a Increment or Append */ 663 private static boolean buildNoDataRegionAction(final RowMutations rowMutations, 664 final List<ExtendedCellScannable> cells, long nonce, 665 final RegionAction.Builder regionActionBuilder, final ClientProtos.Action.Builder actionBuilder, 666 final MutationProto.Builder mutationBuilder) throws IOException { 667 boolean ret = false; 668 for (Mutation mutation : rowMutations.getMutations()) { 669 mutationBuilder.clear(); 670 MutationProto mp; 671 if (mutation instanceof Increment || mutation instanceof Append) { 672 mp = ProtobufUtil.toMutationNoData(getMutationType(mutation), mutation, mutationBuilder, 673 nonce); 674 ret = true; 675 } else { 676 mp = ProtobufUtil.toMutationNoData(getMutationType(mutation), mutation, mutationBuilder); 677 } 678 cells.add(mutation); 679 actionBuilder.clear(); 680 regionActionBuilder.addAction(actionBuilder.setMutation(mp).build()); 681 } 682 return ret; 683 } 684 685 private static MutationType getMutationType(Mutation mutation) { 686 if (mutation instanceof Put) { 687 return MutationType.PUT; 688 } else if (mutation instanceof Delete) { 689 return MutationType.DELETE; 690 } else if (mutation instanceof Increment) { 691 return MutationType.INCREMENT; 692 } else { 693 return MutationType.APPEND; 694 } 695 } 696 697 // End utilities for Client 698 // Start utilities for Admin 699 700 /** 701 * Create a protocol buffer GetRegionInfoRequest for a given region name 702 * @param regionName the name of the region to get info 703 * @return a protocol buffer GetRegionInfoRequest 704 */ 705 public static GetRegionInfoRequest buildGetRegionInfoRequest(final byte[] regionName) { 706 return buildGetRegionInfoRequest(regionName, false); 707 } 708 709 /** 710 * Create a protocol buffer GetRegionInfoRequest for a given region name 711 * @param regionName the name of the region to get info 712 * @param includeCompactionState indicate if the compaction state is requested 713 * @return a protocol buffer GetRegionInfoRequest 714 */ 715 public static GetRegionInfoRequest buildGetRegionInfoRequest(final byte[] regionName, 716 final boolean includeCompactionState) { 717 return buildGetRegionInfoRequest(regionName, includeCompactionState, false); 718 } 719 720 /** 721 * Create a protocol buffer GetRegionInfoRequest, 722 * @param regionName the name of the region to get info 723 * @param includeCompactionState indicate if the compaction state is requested 724 * @param includeBestSplitRow indicate if the bestSplitRow is requested 725 * @return protocol buffer GetRegionInfoRequest 726 */ 727 public static GetRegionInfoRequest buildGetRegionInfoRequest(final byte[] regionName, 728 final boolean includeCompactionState, boolean includeBestSplitRow) { 729 GetRegionInfoRequest.Builder builder = GetRegionInfoRequest.newBuilder(); 730 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 731 builder.setRegion(region); 732 if (includeCompactionState) { 733 builder.setCompactionState(includeCompactionState); 734 } 735 if (includeBestSplitRow) { 736 builder.setBestSplitRow(includeBestSplitRow); 737 } 738 return builder.build(); 739 } 740 741 /** 742 * Create a protocol buffer GetRegionLoadRequest for all regions/regions of a table. 743 * @param tableName the table for which regionLoad should be obtained from RS 744 * @return a protocol buffer GetRegionLoadRequest 745 */ 746 public static GetRegionLoadRequest buildGetRegionLoadRequest(final TableName tableName) { 747 GetRegionLoadRequest.Builder builder = GetRegionLoadRequest.newBuilder(); 748 if (tableName != null) { 749 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 750 } 751 return builder.build(); 752 } 753 754 /** 755 * Create a protocol buffer GetOnlineRegionRequest 756 * @return a protocol buffer GetOnlineRegionRequest 757 */ 758 public static GetOnlineRegionRequest buildGetOnlineRegionRequest() { 759 return GetOnlineRegionRequest.newBuilder().build(); 760 } 761 762 /** 763 * Create a protocol buffer FlushRegionRequest for a given region name 764 * @param regionName the name of the region to get info 765 * @return a protocol buffer FlushRegionRequest 766 */ 767 public static FlushRegionRequest buildFlushRegionRequest(final byte[] regionName) { 768 return buildFlushRegionRequest(regionName, null, false); 769 } 770 771 /** 772 * Create a protocol buffer FlushRegionRequest for a given region name 773 * @param regionName the name of the region to get info 774 * @param columnFamily column family within a region 775 * @return a protocol buffer FlushRegionRequest 776 */ 777 public static FlushRegionRequest buildFlushRegionRequest(final byte[] regionName, 778 byte[] columnFamily, boolean writeFlushWALMarker) { 779 FlushRegionRequest.Builder builder = FlushRegionRequest.newBuilder(); 780 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 781 builder.setRegion(region); 782 builder.setWriteFlushWalMarker(writeFlushWALMarker); 783 if (columnFamily != null) { 784 builder.setFamily(UnsafeByteOperations.unsafeWrap(columnFamily)); 785 } 786 return builder.build(); 787 } 788 789 /** 790 * Create a protocol buffer OpenRegionRequest for a given region 791 * @param server the serverName for the RPC 792 * @param region the region to open 793 * @param favoredNodes a list of favored nodes 794 * @return a protocol buffer OpenRegionRequest 795 */ 796 public static OpenRegionRequest buildOpenRegionRequest(ServerName server, final RegionInfo region, 797 List<ServerName> favoredNodes) { 798 OpenRegionRequest.Builder builder = OpenRegionRequest.newBuilder(); 799 builder.addOpenInfo(buildRegionOpenInfo(region, favoredNodes, -1L)); 800 if (server != null) { 801 builder.setServerStartCode(server.getStartcode()); 802 } 803 builder.setMasterSystemTime(EnvironmentEdgeManager.currentTime()); 804 return builder.build(); 805 } 806 807 /** 808 * Create a protocol buffer UpdateFavoredNodesRequest to update a list of favorednode mappings 809 * @param updateRegionInfos a list of favored node mappings 810 * @return a protocol buffer UpdateFavoredNodesRequest 811 */ 812 public static UpdateFavoredNodesRequest buildUpdateFavoredNodesRequest( 813 final List<Pair<RegionInfo, List<ServerName>>> updateRegionInfos) { 814 UpdateFavoredNodesRequest.Builder ubuilder = UpdateFavoredNodesRequest.newBuilder(); 815 if (updateRegionInfos != null && !updateRegionInfos.isEmpty()) { 816 RegionUpdateInfo.Builder builder = RegionUpdateInfo.newBuilder(); 817 for (Pair<RegionInfo, List<ServerName>> pair : updateRegionInfos) { 818 builder.setRegion(ProtobufUtil.toRegionInfo(pair.getFirst())); 819 for (ServerName server : pair.getSecond()) { 820 builder.addFavoredNodes(ProtobufUtil.toServerName(server)); 821 } 822 ubuilder.addUpdateInfo(builder.build()); 823 builder.clear(); 824 } 825 } 826 return ubuilder.build(); 827 } 828 829 /** 830 * Create a WarmupRegionRequest for a given region name 831 * @param regionInfo Region we are warming up 832 */ 833 public static WarmupRegionRequest buildWarmupRegionRequest(final RegionInfo regionInfo) { 834 WarmupRegionRequest.Builder builder = WarmupRegionRequest.newBuilder(); 835 builder.setRegionInfo(ProtobufUtil.toRegionInfo(regionInfo)); 836 return builder.build(); 837 } 838 839 /** 840 * Create a CompactRegionRequest for a given region name 841 * @param regionName the name of the region to get info 842 * @param major indicator if it is a major compaction 843 * @return a CompactRegionRequest 844 */ 845 public static CompactRegionRequest buildCompactRegionRequest(byte[] regionName, boolean major, 846 byte[] columnFamily) { 847 CompactRegionRequest.Builder builder = CompactRegionRequest.newBuilder(); 848 RegionSpecifier region = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName); 849 builder.setRegion(region); 850 builder.setMajor(major); 851 if (columnFamily != null) { 852 builder.setFamily(UnsafeByteOperations.unsafeWrap(columnFamily)); 853 } 854 return builder.build(); 855 } 856 857 /** 858 * Create a new RollWALWriterRequest 859 * @return a ReplicateWALEntryRequest 860 */ 861 public static RollWALWriterRequest buildRollWALWriterRequest() { 862 return RollWALWriterRequest.getDefaultInstance(); 863 } 864 865 public static RollAllWALWritersRequest buildRollAllWALWritersRequest(long nonceGroup, 866 long nonce) { 867 return RollAllWALWritersRequest.newBuilder().setNonceGroup(nonceGroup).setNonce(nonce).build(); 868 } 869 870 /** 871 * Create a new GetServerInfoRequest 872 * @return a GetServerInfoRequest 873 */ 874 public static GetServerInfoRequest buildGetServerInfoRequest() { 875 return GetServerInfoRequest.getDefaultInstance(); 876 } 877 878 /** 879 * Create a new StopServerRequest 880 * @param reason the reason to stop the server 881 * @return a StopServerRequest 882 */ 883 public static StopServerRequest buildStopServerRequest(final String reason) { 884 StopServerRequest.Builder builder = StopServerRequest.newBuilder(); 885 builder.setReason(reason); 886 return builder.build(); 887 } 888 889 // End utilities for Admin 890 891 /** 892 * Convert a byte array to a protocol buffer RegionSpecifier 893 * @param type the region specifier type 894 * @param value the region specifier byte array value 895 * @return a protocol buffer RegionSpecifier 896 */ 897 public static RegionSpecifier buildRegionSpecifier(final RegionSpecifierType type, 898 final byte[] value) { 899 RegionSpecifier.Builder regionBuilder = RegionSpecifier.newBuilder(); 900 regionBuilder.setValue(UnsafeByteOperations.unsafeWrap(value)); 901 regionBuilder.setType(type); 902 return regionBuilder.build(); 903 } 904 905 /** 906 * Create a protocol buffer AddColumnRequest 907 * @return an AddColumnRequest 908 */ 909 public static AddColumnRequest buildAddColumnRequest(final TableName tableName, 910 final ColumnFamilyDescriptor column, final long nonceGroup, final long nonce) { 911 AddColumnRequest.Builder builder = AddColumnRequest.newBuilder(); 912 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 913 builder.setColumnFamilies(ProtobufUtil.toColumnFamilySchema(column)); 914 builder.setNonceGroup(nonceGroup); 915 builder.setNonce(nonce); 916 return builder.build(); 917 } 918 919 /** 920 * Create a protocol buffer DeleteColumnRequest 921 * @return a DeleteColumnRequest 922 */ 923 public static DeleteColumnRequest buildDeleteColumnRequest(final TableName tableName, 924 final byte[] columnName, final long nonceGroup, final long nonce) { 925 DeleteColumnRequest.Builder builder = DeleteColumnRequest.newBuilder(); 926 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 927 builder.setColumnName(UnsafeByteOperations.unsafeWrap(columnName)); 928 builder.setNonceGroup(nonceGroup); 929 builder.setNonce(nonce); 930 return builder.build(); 931 } 932 933 /** 934 * Create a protocol buffer ModifyColumnRequest 935 * @return an ModifyColumnRequest 936 */ 937 public static ModifyColumnRequest buildModifyColumnRequest(final TableName tableName, 938 final ColumnFamilyDescriptor column, final long nonceGroup, final long nonce) { 939 ModifyColumnRequest.Builder builder = ModifyColumnRequest.newBuilder(); 940 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 941 builder.setColumnFamilies(ProtobufUtil.toColumnFamilySchema(column)); 942 builder.setNonceGroup(nonceGroup); 943 builder.setNonce(nonce); 944 return builder.build(); 945 } 946 947 public static ModifyColumnStoreFileTrackerRequest buildModifyColumnStoreFileTrackerRequest( 948 final TableName tableName, final byte[] family, final String dstSFT, final long nonceGroup, 949 final long nonce) { 950 ModifyColumnStoreFileTrackerRequest.Builder builder = 951 ModifyColumnStoreFileTrackerRequest.newBuilder(); 952 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 953 builder.setFamily(ByteString.copyFrom(family)); 954 builder.setDstSft(dstSFT); 955 builder.setNonceGroup(nonceGroup); 956 builder.setNonce(nonce); 957 return builder.build(); 958 } 959 960 /** 961 * Create a protocol buffer MoveRegionRequest 962 * @return A MoveRegionRequest 963 */ 964 public static MoveRegionRequest buildMoveRegionRequest(byte[] encodedRegionName, 965 ServerName destServerName) { 966 MoveRegionRequest.Builder builder = MoveRegionRequest.newBuilder(); 967 builder 968 .setRegion(buildRegionSpecifier(RegionSpecifierType.ENCODED_REGION_NAME, encodedRegionName)); 969 if (destServerName != null) { 970 builder.setDestServerName(ProtobufUtil.toServerName(destServerName)); 971 } 972 return builder.build(); 973 } 974 975 public static MergeTableRegionsRequest buildMergeTableRegionsRequest( 976 final byte[][] encodedNameOfdaughaterRegions, final boolean forcible, final long nonceGroup, 977 final long nonce) throws DeserializationException { 978 MergeTableRegionsRequest.Builder builder = MergeTableRegionsRequest.newBuilder(); 979 for (int i = 0; i < encodedNameOfdaughaterRegions.length; i++) { 980 builder.addRegion(buildRegionSpecifier(RegionSpecifierType.ENCODED_REGION_NAME, 981 encodedNameOfdaughaterRegions[i])); 982 } 983 builder.setForcible(forcible); 984 builder.setNonceGroup(nonceGroup); 985 builder.setNonce(nonce); 986 return builder.build(); 987 } 988 989 public static SplitTableRegionRequest buildSplitTableRegionRequest(final RegionInfo regionInfo, 990 final byte[] splitRow, final long nonceGroup, final long nonce) 991 throws DeserializationException { 992 SplitTableRegionRequest.Builder builder = SplitTableRegionRequest.newBuilder(); 993 builder.setRegionInfo(ProtobufUtil.toRegionInfo(regionInfo)); 994 if (splitRow != null) { 995 builder.setSplitRow(UnsafeByteOperations.unsafeWrap(splitRow)); 996 } 997 builder.setNonceGroup(nonceGroup); 998 builder.setNonce(nonce); 999 return builder.build(); 1000 } 1001 1002 public static MasterProtos.TruncateRegionRequest 1003 buildTruncateRegionRequest(final RegionInfo regionInfo, final long nonceGroup, final long nonce) 1004 throws DeserializationException { 1005 MasterProtos.TruncateRegionRequest.Builder builder = 1006 MasterProtos.TruncateRegionRequest.newBuilder(); 1007 builder.setRegionInfo(ProtobufUtil.toRegionInfo(regionInfo)); 1008 builder.setNonceGroup(nonceGroup); 1009 builder.setNonce(nonce); 1010 return builder.build(); 1011 } 1012 1013 /** 1014 * Create a protocol buffer AssignRegionRequest 1015 * @return an AssignRegionRequest 1016 */ 1017 public static AssignRegionRequest buildAssignRegionRequest(final byte[] regionName) { 1018 AssignRegionRequest.Builder builder = AssignRegionRequest.newBuilder(); 1019 builder.setRegion(buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName)); 1020 return builder.build(); 1021 } 1022 1023 /** 1024 * Creates a protocol buffer UnassignRegionRequest 1025 * @return an UnassignRegionRequest 1026 */ 1027 public static UnassignRegionRequest buildUnassignRegionRequest(final byte[] regionName) { 1028 UnassignRegionRequest.Builder builder = UnassignRegionRequest.newBuilder(); 1029 builder.setRegion(buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName)); 1030 return builder.build(); 1031 } 1032 1033 /** 1034 * Creates a protocol buffer OfflineRegionRequest 1035 * @return an OfflineRegionRequest 1036 */ 1037 public static OfflineRegionRequest buildOfflineRegionRequest(final byte[] regionName) { 1038 OfflineRegionRequest.Builder builder = OfflineRegionRequest.newBuilder(); 1039 builder.setRegion(buildRegionSpecifier(RegionSpecifierType.REGION_NAME, regionName)); 1040 return builder.build(); 1041 } 1042 1043 /** 1044 * Creates a protocol buffer DeleteTableRequest 1045 * @return a DeleteTableRequest 1046 */ 1047 public static DeleteTableRequest buildDeleteTableRequest(final TableName tableName, 1048 final long nonceGroup, final long nonce) { 1049 DeleteTableRequest.Builder builder = DeleteTableRequest.newBuilder(); 1050 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 1051 builder.setNonceGroup(nonceGroup); 1052 builder.setNonce(nonce); 1053 return builder.build(); 1054 } 1055 1056 /** 1057 * Creates a protocol buffer TruncateTableRequest 1058 * @param tableName name of table to truncate 1059 * @param preserveSplits True if the splits should be preserved 1060 * @return a TruncateTableRequest 1061 */ 1062 public static TruncateTableRequest buildTruncateTableRequest(final TableName tableName, 1063 final boolean preserveSplits, final long nonceGroup, final long nonce) { 1064 TruncateTableRequest.Builder builder = TruncateTableRequest.newBuilder(); 1065 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 1066 builder.setPreserveSplits(preserveSplits); 1067 builder.setNonceGroup(nonceGroup); 1068 builder.setNonce(nonce); 1069 return builder.build(); 1070 } 1071 1072 /** 1073 * Creates a protocol buffer EnableTableRequest 1074 * @return an EnableTableRequest 1075 */ 1076 public static EnableTableRequest buildEnableTableRequest(final TableName tableName, 1077 final long nonceGroup, final long nonce) { 1078 EnableTableRequest.Builder builder = EnableTableRequest.newBuilder(); 1079 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 1080 builder.setNonceGroup(nonceGroup); 1081 builder.setNonce(nonce); 1082 return builder.build(); 1083 } 1084 1085 /** 1086 * Creates a protocol buffer DisableTableRequest 1087 * @return a DisableTableRequest 1088 */ 1089 public static DisableTableRequest buildDisableTableRequest(final TableName tableName, 1090 final long nonceGroup, final long nonce) { 1091 DisableTableRequest.Builder builder = DisableTableRequest.newBuilder(); 1092 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 1093 builder.setNonceGroup(nonceGroup); 1094 builder.setNonce(nonce); 1095 return builder.build(); 1096 } 1097 1098 /** 1099 * Creates a protocol buffer CreateTableRequest 1100 * @return a CreateTableRequest 1101 */ 1102 public static CreateTableRequest buildCreateTableRequest(final TableDescriptor tableDescriptor, 1103 final byte[][] splitKeys, final long nonceGroup, final long nonce) { 1104 CreateTableRequest.Builder builder = CreateTableRequest.newBuilder(); 1105 builder.setTableSchema(ProtobufUtil.toTableSchema(tableDescriptor)); 1106 if (splitKeys != null) { 1107 for (byte[] key : splitKeys) { 1108 builder.addSplitKeys(UnsafeByteOperations.unsafeWrap(key)); 1109 } 1110 } 1111 builder.setNonceGroup(nonceGroup); 1112 builder.setNonce(nonce); 1113 return builder.build(); 1114 } 1115 1116 /** 1117 * Creates a protocol buffer ModifyTableRequest 1118 * @return a ModifyTableRequest 1119 */ 1120 public static ModifyTableRequest buildModifyTableRequest(final TableName tableName, 1121 final TableDescriptor tableDesc, final long nonceGroup, final long nonce, 1122 final boolean reopenRegions) { 1123 ModifyTableRequest.Builder builder = ModifyTableRequest.newBuilder(); 1124 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 1125 builder.setTableSchema(ProtobufUtil.toTableSchema(tableDesc)); 1126 builder.setNonceGroup(nonceGroup); 1127 builder.setNonce(nonce); 1128 builder.setReopenRegions(reopenRegions); 1129 return builder.build(); 1130 } 1131 1132 /** 1133 * Creates a protocol buffer ReopenTableRegionsRequest 1134 * @param tableName table whose regions to reopen 1135 * @param regionNames specific regions to reopen (empty = all regions) 1136 * @param nonceGroup nonce group 1137 * @param nonce nonce 1138 * @return a ReopenTableRegionsRequest 1139 */ 1140 public static ReopenTableRegionsRequest buildReopenTableRegionsRequest(final TableName tableName, 1141 final List<byte[]> regionNames, final long nonceGroup, final long nonce) { 1142 ReopenTableRegionsRequest.Builder builder = ReopenTableRegionsRequest.newBuilder(); 1143 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 1144 1145 if (regionNames != null && !regionNames.isEmpty()) { 1146 for (byte[] regionName : regionNames) { 1147 builder.addRegionNames(UnsafeByteOperations.unsafeWrap(regionName)); 1148 } 1149 } 1150 1151 builder.setNonceGroup(nonceGroup); 1152 builder.setNonce(nonce); 1153 1154 return builder.build(); 1155 } 1156 1157 public static ModifyTableStoreFileTrackerRequest buildModifyTableStoreFileTrackerRequest( 1158 final TableName tableName, final String dstSFT, final long nonceGroup, final long nonce) { 1159 ModifyTableStoreFileTrackerRequest.Builder builder = 1160 ModifyTableStoreFileTrackerRequest.newBuilder(); 1161 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 1162 builder.setDstSft(dstSFT); 1163 builder.setNonceGroup(nonceGroup); 1164 builder.setNonce(nonce); 1165 return builder.build(); 1166 } 1167 1168 /** 1169 * Creates a protocol buffer GetTableDescriptorsRequest 1170 * @return a GetTableDescriptorsRequest 1171 */ 1172 public static GetTableDescriptorsRequest 1173 buildGetTableDescriptorsRequest(final List<TableName> tableNames) { 1174 GetTableDescriptorsRequest.Builder builder = GetTableDescriptorsRequest.newBuilder(); 1175 if (tableNames != null) { 1176 for (TableName tableName : tableNames) { 1177 builder.addTableNames(ProtobufUtil.toProtoTableName(tableName)); 1178 } 1179 } 1180 return builder.build(); 1181 } 1182 1183 /** 1184 * Creates a protocol buffer GetTableDescriptorsRequest 1185 * @param pattern The compiled regular expression to match against 1186 * @param includeSysTables False to match only against userspace tables 1187 * @return a GetTableDescriptorsRequest 1188 */ 1189 public static GetTableDescriptorsRequest buildGetTableDescriptorsRequest(final Pattern pattern, 1190 boolean includeSysTables) { 1191 GetTableDescriptorsRequest.Builder builder = GetTableDescriptorsRequest.newBuilder(); 1192 if (pattern != null) { 1193 builder.setRegex(pattern.toString()); 1194 } 1195 builder.setIncludeSysTables(includeSysTables); 1196 return builder.build(); 1197 } 1198 1199 /** 1200 * Creates a protocol buffer GetTableNamesRequest 1201 * @param pattern The compiled regular expression to match against 1202 * @param includeSysTables False to match only against userspace tables 1203 * @return a GetTableNamesRequest 1204 */ 1205 public static GetTableNamesRequest buildGetTableNamesRequest(final Pattern pattern, 1206 boolean includeSysTables) { 1207 GetTableNamesRequest.Builder builder = GetTableNamesRequest.newBuilder(); 1208 if (pattern != null) { 1209 builder.setRegex(pattern.toString()); 1210 } 1211 builder.setIncludeSysTables(includeSysTables); 1212 return builder.build(); 1213 } 1214 1215 /** 1216 * Creates a protocol buffer SetTableStateInMetaRequest 1217 * @param state table state to update in Meta 1218 * @return a SetTableStateInMetaRequest 1219 */ 1220 public static SetTableStateInMetaRequest buildSetTableStateInMetaRequest(final TableState state) { 1221 return SetTableStateInMetaRequest.newBuilder().setTableState(state.convert()) 1222 .setTableName(ProtobufUtil.toProtoTableName(state.getTableName())).build(); 1223 } 1224 1225 /** 1226 * Creates a protocol buffer SetRegionStateInMetaRequest 1227 * @param nameOrEncodedName2State list of regions states to update in Meta 1228 * @return a SetRegionStateInMetaRequest 1229 */ 1230 public static SetRegionStateInMetaRequest 1231 buildSetRegionStateInMetaRequest(Map<String, RegionState.State> nameOrEncodedName2State) { 1232 SetRegionStateInMetaRequest.Builder builder = SetRegionStateInMetaRequest.newBuilder(); 1233 nameOrEncodedName2State.forEach((name, state) -> { 1234 byte[] bytes = Bytes.toBytes(name); 1235 RegionSpecifier spec; 1236 if (RegionInfo.isEncodedRegionName(bytes)) { 1237 spec = buildRegionSpecifier(RegionSpecifierType.ENCODED_REGION_NAME, bytes); 1238 } else { 1239 spec = buildRegionSpecifier(RegionSpecifierType.REGION_NAME, bytes); 1240 } 1241 builder.addStates(RegionSpecifierAndState.newBuilder().setRegionSpecifier(spec) 1242 .setState(state.convert()).build()); 1243 }); 1244 return builder.build(); 1245 } 1246 1247 /** 1248 * Creates a protocol buffer GetTableDescriptorsRequest for a single table 1249 * @param tableName the table name 1250 * @return a GetTableDescriptorsRequest 1251 */ 1252 public static GetTableDescriptorsRequest 1253 buildGetTableDescriptorsRequest(final TableName tableName) { 1254 return GetTableDescriptorsRequest.newBuilder() 1255 .addTableNames(ProtobufUtil.toProtoTableName(tableName)).build(); 1256 } 1257 1258 /** 1259 * Creates a protocol buffer IsMasterRunningRequest 1260 * @return a IsMasterRunningRequest 1261 */ 1262 public static IsMasterRunningRequest buildIsMasterRunningRequest() { 1263 return IsMasterRunningRequest.newBuilder().build(); 1264 } 1265 1266 /** 1267 * Creates a protocol buffer SetBalancerRunningRequest 1268 * @return a SetBalancerRunningRequest 1269 */ 1270 public static SetBalancerRunningRequest buildSetBalancerRunningRequest(boolean on, 1271 boolean synchronous) { 1272 return SetBalancerRunningRequest.newBuilder().setOn(on).setSynchronous(synchronous).build(); 1273 } 1274 1275 /** 1276 * Creates a protocol buffer IsBalancerEnabledRequest 1277 * @return a IsBalancerEnabledRequest 1278 */ 1279 public static IsBalancerEnabledRequest buildIsBalancerEnabledRequest() { 1280 return IsBalancerEnabledRequest.newBuilder().build(); 1281 } 1282 1283 /** 1284 * Creates a protocol buffer ClearRegionBlockCacheRequest 1285 * @return a ClearRegionBlockCacheRequest 1286 */ 1287 public static ClearRegionBlockCacheRequest 1288 buildClearRegionBlockCacheRequest(List<RegionInfo> hris) { 1289 ClearRegionBlockCacheRequest.Builder builder = ClearRegionBlockCacheRequest.newBuilder(); 1290 hris.forEach(hri -> builder 1291 .addRegion(buildRegionSpecifier(RegionSpecifierType.REGION_NAME, hri.getRegionName()))); 1292 return builder.build(); 1293 } 1294 1295 /** 1296 * Creates a protocol buffer GetClusterStatusRequest 1297 * @return A GetClusterStatusRequest 1298 */ 1299 public static GetClusterStatusRequest buildGetClusterStatusRequest(EnumSet<Option> options) { 1300 return GetClusterStatusRequest.newBuilder() 1301 .addAllOptions(ClusterMetricsBuilder.toOptions(options)).build(); 1302 } 1303 1304 /** 1305 * Creates a request for running a catalog scan 1306 * @return A {@link RunCatalogScanRequest} 1307 */ 1308 public static RunCatalogScanRequest buildCatalogScanRequest() { 1309 return RunCatalogScanRequest.getDefaultInstance(); 1310 } 1311 1312 /** 1313 * Creates a request for enabling/disabling the catalog janitor 1314 * @return A {@link EnableCatalogJanitorRequest} 1315 */ 1316 public static EnableCatalogJanitorRequest buildEnableCatalogJanitorRequest(boolean enable) { 1317 return EnableCatalogJanitorRequest.newBuilder().setEnable(enable).build(); 1318 } 1319 1320 /** 1321 * Creates a request for querying the master whether the catalog janitor is enabled 1322 * @return A {@link IsCatalogJanitorEnabledRequest} 1323 */ 1324 public static IsCatalogJanitorEnabledRequest buildIsCatalogJanitorEnabledRequest() { 1325 return IsCatalogJanitorEnabledRequest.getDefaultInstance(); 1326 } 1327 1328 /** 1329 * Creates a request for running cleaner chore 1330 * @return A {@link RunCleanerChoreRequest} 1331 */ 1332 public static RunCleanerChoreRequest buildRunCleanerChoreRequest() { 1333 return RunCleanerChoreRequest.getDefaultInstance(); 1334 } 1335 1336 /** 1337 * Creates a request for enabling/disabling the cleaner chore 1338 * @return A {@link SetCleanerChoreRunningRequest} 1339 */ 1340 public static SetCleanerChoreRunningRequest buildSetCleanerChoreRunningRequest(boolean on) { 1341 return SetCleanerChoreRunningRequest.newBuilder().setOn(on).build(); 1342 } 1343 1344 /** 1345 * Creates a request for querying the master whether the cleaner chore is enabled 1346 * @return A {@link IsCleanerChoreEnabledRequest} 1347 */ 1348 public static IsCleanerChoreEnabledRequest buildIsCleanerChoreEnabledRequest() { 1349 return IsCleanerChoreEnabledRequest.getDefaultInstance(); 1350 } 1351 1352 /** 1353 * Creates a request for querying the master the last flushed sequence Id for a region 1354 * @return A {@link GetLastFlushedSequenceIdRequest} 1355 */ 1356 public static GetLastFlushedSequenceIdRequest 1357 buildGetLastFlushedSequenceIdRequest(byte[] regionName) { 1358 return GetLastFlushedSequenceIdRequest.newBuilder() 1359 .setRegionName(UnsafeByteOperations.unsafeWrap(regionName)).build(); 1360 } 1361 1362 /** 1363 * Create a RegionOpenInfo based on given region info and version of offline node 1364 */ 1365 public static RegionOpenInfo buildRegionOpenInfo(RegionInfo region, List<ServerName> favoredNodes, 1366 long openProcId) { 1367 RegionOpenInfo.Builder builder = RegionOpenInfo.newBuilder(); 1368 builder.setRegion(ProtobufUtil.toRegionInfo(region)); 1369 if (favoredNodes != null) { 1370 for (ServerName server : favoredNodes) { 1371 builder.addFavoredNodes(ProtobufUtil.toServerName(server)); 1372 } 1373 } 1374 builder.setOpenProcId(openProcId); 1375 return builder.build(); 1376 } 1377 1378 /** 1379 * Creates a protocol buffer NormalizeRequest 1380 * @return a NormalizeRequest 1381 */ 1382 public static NormalizeRequest buildNormalizeRequest(NormalizeTableFilterParams ntfp) { 1383 final NormalizeRequest.Builder builder = NormalizeRequest.newBuilder(); 1384 if (ntfp.getTableNames() != null) { 1385 builder.addAllTableNames(ProtobufUtil.toProtoTableNameList(ntfp.getTableNames())); 1386 } 1387 if (ntfp.getRegex() != null) { 1388 builder.setRegex(ntfp.getRegex()); 1389 } 1390 if (ntfp.getNamespace() != null) { 1391 builder.setNamespace(ntfp.getNamespace()); 1392 } 1393 return builder.build(); 1394 } 1395 1396 /** 1397 * Creates a protocol buffer IsNormalizerEnabledRequest 1398 * @return a IsNormalizerEnabledRequest 1399 */ 1400 public static IsNormalizerEnabledRequest buildIsNormalizerEnabledRequest() { 1401 return IsNormalizerEnabledRequest.newBuilder().build(); 1402 } 1403 1404 /** 1405 * Creates a protocol buffer SetNormalizerRunningRequest 1406 * @return a SetNormalizerRunningRequest 1407 */ 1408 public static SetNormalizerRunningRequest buildSetNormalizerRunningRequest(boolean on) { 1409 return SetNormalizerRunningRequest.newBuilder().setOn(on).build(); 1410 } 1411 1412 /** 1413 * Creates a protocol buffer IsSplitOrMergeEnabledRequest 1414 * @param switchType see {@link org.apache.hadoop.hbase.client.MasterSwitchType} 1415 * @return a IsSplitOrMergeEnabledRequest 1416 */ 1417 public static IsSplitOrMergeEnabledRequest 1418 buildIsSplitOrMergeEnabledRequest(MasterSwitchType switchType) { 1419 IsSplitOrMergeEnabledRequest.Builder builder = IsSplitOrMergeEnabledRequest.newBuilder(); 1420 builder.setSwitchType(convert(switchType)); 1421 return builder.build(); 1422 } 1423 1424 /** 1425 * Creates a protocol buffer SetSplitOrMergeEnabledRequest 1426 * @param enabled switch is enabled or not 1427 * @param synchronous set switch sync? 1428 * @param switchTypes see {@link org.apache.hadoop.hbase.client.MasterSwitchType}, it is a list. 1429 * @return a SetSplitOrMergeEnabledRequest 1430 */ 1431 public static SetSplitOrMergeEnabledRequest buildSetSplitOrMergeEnabledRequest(boolean enabled, 1432 boolean synchronous, MasterSwitchType... switchTypes) { 1433 SetSplitOrMergeEnabledRequest.Builder builder = SetSplitOrMergeEnabledRequest.newBuilder(); 1434 builder.setEnabled(enabled); 1435 builder.setSynchronous(synchronous); 1436 for (MasterSwitchType switchType : switchTypes) { 1437 builder.addSwitchTypes(convert(switchType)); 1438 } 1439 return builder.build(); 1440 } 1441 1442 private static MasterProtos.MasterSwitchType convert(MasterSwitchType switchType) { 1443 switch (switchType) { 1444 case SPLIT: 1445 return MasterProtos.MasterSwitchType.SPLIT; 1446 case MERGE: 1447 return MasterProtos.MasterSwitchType.MERGE; 1448 default: 1449 break; 1450 } 1451 throw new UnsupportedOperationException("Unsupport switch type:" + switchType); 1452 } 1453 1454 public static ReplicationProtos.AddReplicationPeerRequest buildAddReplicationPeerRequest( 1455 String peerId, ReplicationPeerConfig peerConfig, boolean enabled) { 1456 AddReplicationPeerRequest.Builder builder = AddReplicationPeerRequest.newBuilder(); 1457 builder.setPeerId(peerId); 1458 builder.setPeerConfig(ReplicationPeerConfigUtil.convert(peerConfig)); 1459 ReplicationProtos.ReplicationState.Builder stateBuilder = 1460 ReplicationProtos.ReplicationState.newBuilder(); 1461 stateBuilder.setState(enabled 1462 ? ReplicationProtos.ReplicationState.State.ENABLED 1463 : ReplicationProtos.ReplicationState.State.DISABLED); 1464 builder.setPeerState(stateBuilder.build()); 1465 return builder.build(); 1466 } 1467 1468 public static ReplicationProtos.RemoveReplicationPeerRequest 1469 buildRemoveReplicationPeerRequest(String peerId) { 1470 RemoveReplicationPeerRequest.Builder builder = RemoveReplicationPeerRequest.newBuilder(); 1471 builder.setPeerId(peerId); 1472 return builder.build(); 1473 } 1474 1475 public static ReplicationProtos.EnableReplicationPeerRequest 1476 buildEnableReplicationPeerRequest(String peerId) { 1477 EnableReplicationPeerRequest.Builder builder = EnableReplicationPeerRequest.newBuilder(); 1478 builder.setPeerId(peerId); 1479 return builder.build(); 1480 } 1481 1482 public static ReplicationProtos.DisableReplicationPeerRequest 1483 buildDisableReplicationPeerRequest(String peerId) { 1484 DisableReplicationPeerRequest.Builder builder = DisableReplicationPeerRequest.newBuilder(); 1485 builder.setPeerId(peerId); 1486 return builder.build(); 1487 } 1488 1489 public static GetReplicationPeerConfigRequest 1490 buildGetReplicationPeerConfigRequest(String peerId) { 1491 GetReplicationPeerConfigRequest.Builder builder = GetReplicationPeerConfigRequest.newBuilder(); 1492 builder.setPeerId(peerId); 1493 return builder.build(); 1494 } 1495 1496 public static UpdateReplicationPeerConfigRequest 1497 buildUpdateReplicationPeerConfigRequest(String peerId, ReplicationPeerConfig peerConfig) { 1498 UpdateReplicationPeerConfigRequest.Builder builder = 1499 UpdateReplicationPeerConfigRequest.newBuilder(); 1500 builder.setPeerId(peerId); 1501 builder.setPeerConfig(ReplicationPeerConfigUtil.convert(peerConfig)); 1502 return builder.build(); 1503 } 1504 1505 public static ListReplicationPeersRequest buildListReplicationPeersRequest(Pattern pattern) { 1506 ListReplicationPeersRequest.Builder builder = ListReplicationPeersRequest.newBuilder(); 1507 if (pattern != null) { 1508 builder.setRegex(pattern.toString()); 1509 } 1510 return builder.build(); 1511 } 1512 1513 /** 1514 * Creates a protocol buffer CreateNamespaceRequest 1515 * @return a CreateNamespaceRequest 1516 */ 1517 public static CreateNamespaceRequest 1518 buildCreateNamespaceRequest(final NamespaceDescriptor descriptor) { 1519 CreateNamespaceRequest.Builder builder = CreateNamespaceRequest.newBuilder(); 1520 builder.setNamespaceDescriptor(ProtobufUtil.toProtoNamespaceDescriptor(descriptor)); 1521 return builder.build(); 1522 } 1523 1524 /** 1525 * Creates a protocol buffer ModifyNamespaceRequest 1526 * @return a ModifyNamespaceRequest 1527 */ 1528 public static ModifyNamespaceRequest 1529 buildModifyNamespaceRequest(final NamespaceDescriptor descriptor) { 1530 ModifyNamespaceRequest.Builder builder = ModifyNamespaceRequest.newBuilder(); 1531 builder.setNamespaceDescriptor(ProtobufUtil.toProtoNamespaceDescriptor(descriptor)); 1532 return builder.build(); 1533 } 1534 1535 /** 1536 * Creates a protocol buffer DeleteNamespaceRequest 1537 * @return a DeleteNamespaceRequest 1538 */ 1539 public static DeleteNamespaceRequest buildDeleteNamespaceRequest(final String name) { 1540 DeleteNamespaceRequest.Builder builder = DeleteNamespaceRequest.newBuilder(); 1541 builder.setNamespaceName(name); 1542 return builder.build(); 1543 } 1544 1545 /** 1546 * Creates a protocol buffer GetNamespaceDescriptorRequest 1547 * @return a GetNamespaceDescriptorRequest 1548 */ 1549 public static GetNamespaceDescriptorRequest 1550 buildGetNamespaceDescriptorRequest(final String name) { 1551 GetNamespaceDescriptorRequest.Builder builder = GetNamespaceDescriptorRequest.newBuilder(); 1552 builder.setNamespaceName(name); 1553 return builder.build(); 1554 } 1555 1556 public static ClearCompactionQueuesRequest buildClearCompactionQueuesRequest(Set<String> queues) { 1557 ClearCompactionQueuesRequest.Builder builder = ClearCompactionQueuesRequest.newBuilder(); 1558 for (String name : queues) { 1559 builder.addQueueName(name); 1560 } 1561 return builder.build(); 1562 } 1563 1564 public static ClearDeadServersRequest 1565 buildClearDeadServersRequest(Collection<ServerName> deadServers) { 1566 ClearDeadServersRequest.Builder builder = ClearDeadServersRequest.newBuilder(); 1567 for (ServerName server : deadServers) { 1568 builder.addServerName(ProtobufUtil.toServerName(server)); 1569 } 1570 return builder.build(); 1571 } 1572 1573 /** 1574 * Returns a {@link GetSpaceQuotaRegionSizesRequest} object. 1575 */ 1576 public static GetSpaceQuotaRegionSizesRequest buildGetSpaceQuotaRegionSizesRequest() { 1577 return GetSpaceQuotaRegionSizesRequest.getDefaultInstance(); 1578 } 1579 1580 /** 1581 * Returns a {@link GetSpaceQuotaSnapshotsRequest} object. 1582 */ 1583 public static GetSpaceQuotaSnapshotsRequest buildGetSpaceQuotaSnapshotsRequest() { 1584 return GetSpaceQuotaSnapshotsRequest.getDefaultInstance(); 1585 } 1586 1587 /** 1588 * Returns a {@link GetQuotaStatesRequest} object. 1589 */ 1590 public static GetQuotaStatesRequest buildGetQuotaStatesRequest() { 1591 return GetQuotaStatesRequest.getDefaultInstance(); 1592 } 1593 1594 public static DecommissionRegionServersRequest 1595 buildDecommissionRegionServersRequest(List<ServerName> servers, boolean offload) { 1596 return DecommissionRegionServersRequest.newBuilder() 1597 .addAllServerName(toProtoServerNames(servers)).setOffload(offload).build(); 1598 } 1599 1600 public static RecommissionRegionServerRequest 1601 buildRecommissionRegionServerRequest(ServerName server, List<byte[]> encodedRegionNames) { 1602 RecommissionRegionServerRequest.Builder builder = RecommissionRegionServerRequest.newBuilder(); 1603 if (encodedRegionNames != null) { 1604 for (byte[] name : encodedRegionNames) { 1605 builder.addRegion(buildRegionSpecifier(RegionSpecifierType.ENCODED_REGION_NAME, name)); 1606 } 1607 } 1608 return builder.setServerName(ProtobufUtil.toServerName(server)).build(); 1609 } 1610 1611 private static List<HBaseProtos.ServerName> toProtoServerNames(List<ServerName> servers) { 1612 List<HBaseProtos.ServerName> pbServers = new ArrayList<>(servers.size()); 1613 for (ServerName server : servers) { 1614 pbServers.add(ProtobufUtil.toServerName(server)); 1615 } 1616 return pbServers; 1617 } 1618 1619 public static TransitReplicationPeerSyncReplicationStateRequest 1620 buildTransitReplicationPeerSyncReplicationStateRequest(String peerId, 1621 SyncReplicationState state) { 1622 return TransitReplicationPeerSyncReplicationStateRequest.newBuilder().setPeerId(peerId) 1623 .setSyncReplicationState(ReplicationPeerConfigUtil.toSyncReplicationState(state)).build(); 1624 } 1625 1626 // HBCK2 1627 public static MasterProtos.AssignsRequest toAssignRegionsRequest(List<String> encodedRegionNames, 1628 boolean override, boolean force) { 1629 MasterProtos.AssignsRequest.Builder b = MasterProtos.AssignsRequest.newBuilder(); 1630 return b.addAllRegion(toEncodedRegionNameRegionSpecifiers(encodedRegionNames)) 1631 .setOverride(override).setForce(force).build(); 1632 } 1633 1634 public static MasterProtos.UnassignsRequest 1635 toUnassignRegionsRequest(List<String> encodedRegionNames, boolean override, boolean force) { 1636 MasterProtos.UnassignsRequest.Builder b = MasterProtos.UnassignsRequest.newBuilder(); 1637 return b.addAllRegion(toEncodedRegionNameRegionSpecifiers(encodedRegionNames)) 1638 .setOverride(override).setForce(force).build(); 1639 } 1640 1641 public static MasterProtos.ScheduleServerCrashProcedureRequest 1642 toScheduleServerCrashProcedureRequest(List<ServerName> serverNames) { 1643 MasterProtos.ScheduleServerCrashProcedureRequest.Builder builder = 1644 MasterProtos.ScheduleServerCrashProcedureRequest.newBuilder(); 1645 serverNames.stream().map(ProtobufUtil::toServerName).forEach(sn -> builder.addServerName(sn)); 1646 return builder.build(); 1647 } 1648 1649 private static List<RegionSpecifier> 1650 toEncodedRegionNameRegionSpecifiers(List<String> encodedRegionNames) { 1651 return encodedRegionNames.stream() 1652 .map(r -> buildRegionSpecifier(RegionSpecifierType.ENCODED_REGION_NAME, Bytes.toBytes(r))) 1653 .collect(Collectors.toList()); 1654 } 1655 1656 /** 1657 * Creates SetSnapshotCleanupRequest for turning on/off auto snapshot cleanup 1658 * @param enabled Set to <code>true</code> to enable, <code>false</code> to disable. 1659 * @param synchronous If <code>true</code>, it waits until current snapshot cleanup is completed, 1660 * if outstanding. 1661 * @return a SetSnapshotCleanupRequest 1662 */ 1663 public static SetSnapshotCleanupRequest buildSetSnapshotCleanupRequest(final boolean enabled, 1664 final boolean synchronous) { 1665 return SetSnapshotCleanupRequest.newBuilder().setEnabled(enabled).setSynchronous(synchronous) 1666 .build(); 1667 } 1668 1669 /** 1670 * Creates IsSnapshotCleanupEnabledRequest to determine if auto snapshot cleanup based on TTL 1671 * expiration is turned on 1672 */ 1673 public static IsSnapshotCleanupEnabledRequest buildIsSnapshotCleanupEnabledRequest() { 1674 return IsSnapshotCleanupEnabledRequest.newBuilder().build(); 1675 } 1676 1677 /** 1678 * Build RPC request payload for getLogEntries 1679 * @param filterParams map of filter params 1680 * @param limit limit for no of records that server returns 1681 * @param logType type of the log records 1682 * @return request payload {@link HBaseProtos.LogRequest} 1683 */ 1684 public static HBaseProtos.LogRequest buildSlowLogResponseRequest( 1685 final Map<String, Object> filterParams, final int limit, final String logType) { 1686 SlowLogResponseRequest.Builder builder = SlowLogResponseRequest.newBuilder(); 1687 builder.setLimit(limit); 1688 if (logType.equals("SLOW_LOG")) { 1689 builder.setLogType(SlowLogResponseRequest.LogType.SLOW_LOG); 1690 } else if (logType.equals("LARGE_LOG")) { 1691 builder.setLogType(SlowLogResponseRequest.LogType.LARGE_LOG); 1692 } 1693 boolean filterByAnd = false; 1694 if (MapUtils.isNotEmpty(filterParams)) { 1695 if (filterParams.containsKey("clientAddress")) { 1696 final String clientAddress = (String) filterParams.get("clientAddress"); 1697 if (StringUtils.isNotEmpty(clientAddress)) { 1698 builder.setClientAddress(clientAddress); 1699 } 1700 } 1701 if (filterParams.containsKey("regionName")) { 1702 final String regionName = (String) filterParams.get("regionName"); 1703 if (StringUtils.isNotEmpty(regionName)) { 1704 builder.setRegionName(regionName); 1705 } 1706 } 1707 if (filterParams.containsKey("tableName")) { 1708 final String tableName = (String) filterParams.get("tableName"); 1709 if (StringUtils.isNotEmpty(tableName)) { 1710 builder.setTableName(tableName); 1711 } 1712 } 1713 if (filterParams.containsKey("userName")) { 1714 final String userName = (String) filterParams.get("userName"); 1715 if (StringUtils.isNotEmpty(userName)) { 1716 builder.setUserName(userName); 1717 } 1718 } 1719 if (filterParams.containsKey("filterByOperator")) { 1720 final String filterByOperator = (String) filterParams.get("filterByOperator"); 1721 if (StringUtils.isNotEmpty(filterByOperator)) { 1722 if (filterByOperator.toUpperCase().equals("AND")) { 1723 filterByAnd = true; 1724 } 1725 } 1726 } 1727 } 1728 if (filterByAnd) { 1729 builder.setFilterByOperator(SlowLogResponseRequest.FilterByOperator.AND); 1730 } else { 1731 builder.setFilterByOperator(SlowLogResponseRequest.FilterByOperator.OR); 1732 } 1733 SlowLogResponseRequest slowLogResponseRequest = builder.build(); 1734 return HBaseProtos.LogRequest.newBuilder() 1735 .setLogClassName(slowLogResponseRequest.getClass().getName()) 1736 .setLogMessage(slowLogResponseRequest.toByteString()).build(); 1737 } 1738 1739 /** 1740 * Create a protocol buffer {@link ClearSlowLogResponseRequest} 1741 * @return a protocol buffer ClearSlowLogResponseRequest 1742 */ 1743 public static ClearSlowLogResponseRequest buildClearSlowLogResponseRequest() { 1744 return ClearSlowLogResponseRequest.newBuilder().build(); 1745 } 1746 1747 public static MoveServersRequest buildMoveServersRequest(Set<Address> servers, 1748 String targetGroup) { 1749 Set<HBaseProtos.ServerName> hostPorts = Sets.newHashSet(); 1750 for (Address el : servers) { 1751 hostPorts.add(HBaseProtos.ServerName.newBuilder().setHostName(el.getHostname()) 1752 .setPort(el.getPort()).build()); 1753 } 1754 return MoveServersRequest.newBuilder().setTargetGroup(targetGroup).addAllServers(hostPorts) 1755 .build(); 1756 } 1757 1758 public static RemoveServersRequest buildRemoveServersRequest(Set<Address> servers) { 1759 Set<HBaseProtos.ServerName> hostPorts = Sets.newHashSet(); 1760 for (Address el : servers) { 1761 hostPorts.add(HBaseProtos.ServerName.newBuilder().setHostName(el.getHostname()) 1762 .setPort(el.getPort()).build()); 1763 } 1764 return RemoveServersRequest.newBuilder().addAllServers(hostPorts).build(); 1765 } 1766 1767 public static FlushTableRequest buildFlushTableRequest(final TableName tableName, 1768 final List<byte[]> columnFamilies, final long nonceGroup, final long nonce) { 1769 FlushTableRequest.Builder builder = FlushTableRequest.newBuilder(); 1770 builder.setTableName(ProtobufUtil.toProtoTableName(tableName)); 1771 if (!columnFamilies.isEmpty()) { 1772 for (byte[] columnFamily : columnFamilies) { 1773 builder.addColumnFamily(UnsafeByteOperations.unsafeWrap(columnFamily)); 1774 } 1775 } 1776 return builder.setNonceGroup(nonceGroup).setNonce(nonce).build(); 1777 } 1778}