Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 761CE200CAA for ; Sat, 17 Jun 2017 17:00:06 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id 745C8160BF9; Sat, 17 Jun 2017 15:00:06 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 795C4160BEF for ; Sat, 17 Jun 2017 17:00:04 +0200 (CEST) Received: (qmail 27061 invoked by uid 500); 17 Jun 2017 15:00:03 -0000 Mailing-List: contact commits-help@hbase.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@hbase.apache.org Delivered-To: mailing list commits@hbase.apache.org Received: (qmail 26611 invoked by uid 99); 17 Jun 2017 15:00:02 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Sat, 17 Jun 2017 15:00:02 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 1DFE8E93E1; Sat, 17 Jun 2017 15:00:00 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: git-site-role@apache.org To: commits@hbase.apache.org Date: Sat, 17 Jun 2017 15:00:14 -0000 Message-Id: In-Reply-To: <76853ad939d44fc69d78b7344608caf2@git.apache.org> References: <76853ad939d44fc69d78b7344608caf2@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [15/22] hbase-site git commit: Published site at 82d554e3783372cc6b05489452c815b57c06f6cd. archived-at: Sat, 17 Jun 2017 15:00:06 -0000 http://git-wip-us.apache.org/repos/asf/hbase-site/blob/b9830530/devapidocs/src-html/org/apache/hadoop/hbase/master/procedure/RSProcedureDispatcher.ExecuteProceduresRemoteCall.html ---------------------------------------------------------------------- diff --git a/devapidocs/src-html/org/apache/hadoop/hbase/master/procedure/RSProcedureDispatcher.ExecuteProceduresRemoteCall.html b/devapidocs/src-html/org/apache/hadoop/hbase/master/procedure/RSProcedureDispatcher.ExecuteProceduresRemoteCall.html index f0a9b50..13cebd8 100644 --- a/devapidocs/src-html/org/apache/hadoop/hbase/master/procedure/RSProcedureDispatcher.ExecuteProceduresRemoteCall.html +++ b/devapidocs/src-html/org/apache/hadoop/hbase/master/procedure/RSProcedureDispatcher.ExecuteProceduresRemoteCall.html @@ -69,7 +69,7 @@ 061 "hbase.regionserver.rpc.startup.waittime"; 062 private static final int DEFAULT_RS_RPC_STARTUP_WAIT_TIME = 60000; 063 -064 private static final int RS_VERSION_WITH_EXEC_PROCS = 0x0201000; // 2.1 +064 private static final int RS_VERSION_WITH_EXEC_PROCS = 0x0200000; // 2.0 065 066 protected final MasterServices master; 067 protected final long rsStartupWaitTime; @@ -267,286 +267,289 @@ 259 final MasterProcedureEnv env = master.getMasterProcedureExecutor().getEnvironment(); 260 261 request = ExecuteProceduresRequest.newBuilder(); -262 splitAndResolveOperation(getServerName(), operations, this); -263 -264 try { -265 final ExecuteProceduresResponse response = sendRequest(getServerName(), request.build()); -266 remoteCallCompleted(env, response); -267 } catch (IOException e) { -268 e = unwrapException(e); -269 // TODO: In the future some operation may want to bail out early. -270 // TODO: How many times should we retry (use numberOfAttemptsSoFar) -271 if (!scheduleForRetry(e)) { -272 remoteCallFailed(env, e); -273 } -274 } -275 return null; -276 } -277 -278 public void dispatchOpenRequests(final MasterProcedureEnv env, -279 final List<RegionOpenOperation> operations) { -280 request.addOpenRegion(buildOpenRegionRequest(env, getServerName(), operations)); -281 } -282 -283 public void dispatchCloseRequests(final MasterProcedureEnv env, -284 final List<RegionCloseOperation> operations) { -285 for (RegionCloseOperation op: operations) { -286 request.addCloseRegion(op.buildCloseRegionRequest(getServerName())); -287 } -288 } -289 -290 protected ExecuteProceduresResponse sendRequest(final ServerName serverName, -291 final ExecuteProceduresRequest request) throws IOException { -292 try { -293 return getRsAdmin().executeProcedures(null, request); -294 } catch (ServiceException se) { -295 throw ProtobufUtil.getRemoteException(se); -296 } -297 } -298 -299 -300 private void remoteCallCompleted(final MasterProcedureEnv env, -301 final ExecuteProceduresResponse response) { -302 /* -303 for (RemoteProcedure proc: operations) { -304 proc.remoteCallCompleted(env, getServerName(), response); -305 }*/ -306 } -307 -308 private void remoteCallFailed(final MasterProcedureEnv env, final IOException e) { -309 for (RemoteProcedure proc: operations) { -310 proc.remoteCallFailed(env, getServerName(), e); -311 } -312 } -313 } -314 -315 // ========================================================================== -316 // Compatibility calls -317 // Since we don't have a "batch proc-exec" request on the target RS -318 // we have to chunk the requests by type and dispatch the specific request. -319 // ========================================================================== -320 private static OpenRegionRequest buildOpenRegionRequest(final MasterProcedureEnv env, -321 final ServerName serverName, final List<RegionOpenOperation> operations) { -322 final OpenRegionRequest.Builder builder = OpenRegionRequest.newBuilder(); -323 builder.setServerStartCode(serverName.getStartcode()); -324 builder.setMasterSystemTime(EnvironmentEdgeManager.currentTime()); -325 for (RegionOpenOperation op: operations) { -326 builder.addOpenInfo(op.buildRegionOpenInfoRequest(env)); -327 } -328 return builder.build(); -329 } -330 -331 private final class OpenRegionRemoteCall extends AbstractRSRemoteCall { -332 private final List<RegionOpenOperation> operations; +262 if (LOG.isTraceEnabled()) { +263 LOG.trace("Building request with operations count=" + operations.size()); +264 } +265 splitAndResolveOperation(getServerName(), operations, this); +266 +267 try { +268 final ExecuteProceduresResponse response = sendRequest(getServerName(), request.build()); +269 remoteCallCompleted(env, response); +270 } catch (IOException e) { +271 e = unwrapException(e); +272 // TODO: In the future some operation may want to bail out early. +273 // TODO: How many times should we retry (use numberOfAttemptsSoFar) +274 if (!scheduleForRetry(e)) { +275 remoteCallFailed(env, e); +276 } +277 } +278 return null; +279 } +280 +281 public void dispatchOpenRequests(final MasterProcedureEnv env, +282 final List<RegionOpenOperation> operations) { +283 request.addOpenRegion(buildOpenRegionRequest(env, getServerName(), operations)); +284 } +285 +286 public void dispatchCloseRequests(final MasterProcedureEnv env, +287 final List<RegionCloseOperation> operations) { +288 for (RegionCloseOperation op: operations) { +289 request.addCloseRegion(op.buildCloseRegionRequest(getServerName())); +290 } +291 } +292 +293 protected ExecuteProceduresResponse sendRequest(final ServerName serverName, +294 final ExecuteProceduresRequest request) throws IOException { +295 try { +296 return getRsAdmin().executeProcedures(null, request); +297 } catch (ServiceException se) { +298 throw ProtobufUtil.getRemoteException(se); +299 } +300 } +301 +302 +303 private void remoteCallCompleted(final MasterProcedureEnv env, +304 final ExecuteProceduresResponse response) { +305 /* +306 for (RemoteProcedure proc: operations) { +307 proc.remoteCallCompleted(env, getServerName(), response); +308 }*/ +309 } +310 +311 private void remoteCallFailed(final MasterProcedureEnv env, final IOException e) { +312 for (RemoteProcedure proc: operations) { +313 proc.remoteCallFailed(env, getServerName(), e); +314 } +315 } +316 } +317 +318 // ========================================================================== +319 // Compatibility calls +320 // Since we don't have a "batch proc-exec" request on the target RS +321 // we have to chunk the requests by type and dispatch the specific request. +322 // ========================================================================== +323 private static OpenRegionRequest buildOpenRegionRequest(final MasterProcedureEnv env, +324 final ServerName serverName, final List<RegionOpenOperation> operations) { +325 final OpenRegionRequest.Builder builder = OpenRegionRequest.newBuilder(); +326 builder.setServerStartCode(serverName.getStartcode()); +327 builder.setMasterSystemTime(EnvironmentEdgeManager.currentTime()); +328 for (RegionOpenOperation op: operations) { +329 builder.addOpenInfo(op.buildRegionOpenInfoRequest(env)); +330 } +331 return builder.build(); +332 } 333 -334 public OpenRegionRemoteCall(final ServerName serverName, -335 final List<RegionOpenOperation> operations) { -336 super(serverName); -337 this.operations = operations; -338 } -339 -340 @Override -341 public Void call() { -342 final MasterProcedureEnv env = master.getMasterProcedureExecutor().getEnvironment(); -343 final OpenRegionRequest request = buildOpenRegionRequest(env, getServerName(), operations); -344 -345 try { -346 OpenRegionResponse response = sendRequest(getServerName(), request); -347 remoteCallCompleted(env, response); -348 } catch (IOException e) { -349 e = unwrapException(e); -350 // TODO: In the future some operation may want to bail out early. -351 // TODO: How many times should we retry (use numberOfAttemptsSoFar) -352 if (!scheduleForRetry(e)) { -353 remoteCallFailed(env, e); -354 } -355 } -356 return null; -357 } -358 -359 private OpenRegionResponse sendRequest(final ServerName serverName, -360 final OpenRegionRequest request) throws IOException { -361 try { -362 return getRsAdmin().openRegion(null, request); -363 } catch (ServiceException se) { -364 throw ProtobufUtil.getRemoteException(se); -365 } -366 } -367 -368 private void remoteCallCompleted(final MasterProcedureEnv env, -369 final OpenRegionResponse response) { -370 int index = 0; -371 for (RegionOpenOperation op: operations) { -372 OpenRegionResponse.RegionOpeningState state = response.getOpeningState(index++); -373 op.setFailedOpen(state == OpenRegionResponse.RegionOpeningState.FAILED_OPENING); -374 op.getRemoteProcedure().remoteCallCompleted(env, getServerName(), op); -375 } -376 } -377 -378 private void remoteCallFailed(final MasterProcedureEnv env, final IOException e) { -379 for (RegionOpenOperation op: operations) { -380 op.getRemoteProcedure().remoteCallFailed(env, getServerName(), e); -381 } -382 } -383 } -384 -385 private final class CloseRegionRemoteCall extends AbstractRSRemoteCall { -386 private final RegionCloseOperation operation; +334 private final class OpenRegionRemoteCall extends AbstractRSRemoteCall { +335 private final List<RegionOpenOperation> operations; +336 +337 public OpenRegionRemoteCall(final ServerName serverName, +338 final List<RegionOpenOperation> operations) { +339 super(serverName); +340 this.operations = operations; +341 } +342 +343 @Override +344 public Void call() { +345 final MasterProcedureEnv env = master.getMasterProcedureExecutor().getEnvironment(); +346 final OpenRegionRequest request = buildOpenRegionRequest(env, getServerName(), operations); +347 +348 try { +349 OpenRegionResponse response = sendRequest(getServerName(), request); +350 remoteCallCompleted(env, response); +351 } catch (IOException e) { +352 e = unwrapException(e); +353 // TODO: In the future some operation may want to bail out early. +354 // TODO: How many times should we retry (use numberOfAttemptsSoFar) +355 if (!scheduleForRetry(e)) { +356 remoteCallFailed(env, e); +357 } +358 } +359 return null; +360 } +361 +362 private OpenRegionResponse sendRequest(final ServerName serverName, +363 final OpenRegionRequest request) throws IOException { +364 try { +365 return getRsAdmin().openRegion(null, request); +366 } catch (ServiceException se) { +367 throw ProtobufUtil.getRemoteException(se); +368 } +369 } +370 +371 private void remoteCallCompleted(final MasterProcedureEnv env, +372 final OpenRegionResponse response) { +373 int index = 0; +374 for (RegionOpenOperation op: operations) { +375 OpenRegionResponse.RegionOpeningState state = response.getOpeningState(index++); +376 op.setFailedOpen(state == OpenRegionResponse.RegionOpeningState.FAILED_OPENING); +377 op.getRemoteProcedure().remoteCallCompleted(env, getServerName(), op); +378 } +379 } +380 +381 private void remoteCallFailed(final MasterProcedureEnv env, final IOException e) { +382 for (RegionOpenOperation op: operations) { +383 op.getRemoteProcedure().remoteCallFailed(env, getServerName(), e); +384 } +385 } +386 } 387 -388 public CloseRegionRemoteCall(final ServerName serverName, -389 final RegionCloseOperation operation) { -390 super(serverName); -391 this.operation = operation; -392 } -393 -394 @Override -395 public Void call() { -396 final MasterProcedureEnv env = master.getMasterProcedureExecutor().getEnvironment(); -397 final CloseRegionRequest request = operation.buildCloseRegionRequest(getServerName()); -398 try { -399 CloseRegionResponse response = sendRequest(getServerName(), request); -400 remoteCallCompleted(env, response); -401 } catch (IOException e) { -402 e = unwrapException(e); -403 // TODO: In the future some operation may want to bail out early. -404 // TODO: How many times should we retry (use numberOfAttemptsSoFar) -405 if (!scheduleForRetry(e)) { -406 remoteCallFailed(env, e); -407 } -408 } -409 return null; -410 } -411 -412 private CloseRegionResponse sendRequest(final ServerName serverName, -413 final CloseRegionRequest request) throws IOException { -414 try { -415 return getRsAdmin().closeRegion(null, request); -416 } catch (ServiceException se) { -417 throw ProtobufUtil.getRemoteException(se); -418 } -419 } -420 -421 private void remoteCallCompleted(final MasterProcedureEnv env, -422 final CloseRegionResponse response) { -423 operation.setClosed(response.getClosed()); -424 operation.getRemoteProcedure().remoteCallCompleted(env, getServerName(), operation); -425 } -426 -427 private void remoteCallFailed(final MasterProcedureEnv env, final IOException e) { -428 operation.getRemoteProcedure().remoteCallFailed(env, getServerName(), e); -429 } -430 } -431 -432 protected class CompatRemoteProcedureResolver implements Callable<Void>, RemoteProcedureResolver { -433 private final Set<RemoteProcedure> operations; -434 private final ServerName serverName; -435 -436 public CompatRemoteProcedureResolver(final ServerName serverName, -437 final Set<RemoteProcedure> operations) { -438 this.serverName = serverName; -439 this.operations = operations; -440 } -441 -442 @Override -443 public Void call() { -444 splitAndResolveOperation(serverName, operations, this); -445 return null; -446 } -447 -448 public void dispatchOpenRequests(final MasterProcedureEnv env, -449 final List<RegionOpenOperation> operations) { -450 submitTask(new OpenRegionRemoteCall(serverName, operations)); -451 } -452 -453 public void dispatchCloseRequests(final MasterProcedureEnv env, -454 final List<RegionCloseOperation> operations) { -455 for (RegionCloseOperation op: operations) { -456 submitTask(new CloseRegionRemoteCall(serverName, op)); -457 } -458 } -459 } -460 -461 // ========================================================================== -462 // RPC Messages -463 // - ServerOperation: refreshConfig, grant, revoke, ... -464 // - RegionOperation: open, close, flush, snapshot, ... -465 // ========================================================================== -466 public static abstract class ServerOperation extends RemoteOperation { -467 protected ServerOperation(final RemoteProcedure remoteProcedure) { -468 super(remoteProcedure); -469 } -470 } -471 -472 public static abstract class RegionOperation extends RemoteOperation { -473 private final HRegionInfo regionInfo; +388 private final class CloseRegionRemoteCall extends AbstractRSRemoteCall { +389 private final RegionCloseOperation operation; +390 +391 public CloseRegionRemoteCall(final ServerName serverName, +392 final RegionCloseOperation operation) { +393 super(serverName); +394 this.operation = operation; +395 } +396 +397 @Override +398 public Void call() { +399 final MasterProcedureEnv env = master.getMasterProcedureExecutor().getEnvironment(); +400 final CloseRegionRequest request = operation.buildCloseRegionRequest(getServerName()); +401 try { +402 CloseRegionResponse response = sendRequest(getServerName(), request); +403 remoteCallCompleted(env, response); +404 } catch (IOException e) { +405 e = unwrapException(e); +406 // TODO: In the future some operation may want to bail out early. +407 // TODO: How many times should we retry (use numberOfAttemptsSoFar) +408 if (!scheduleForRetry(e)) { +409 remoteCallFailed(env, e); +410 } +411 } +412 return null; +413 } +414 +415 private CloseRegionResponse sendRequest(final ServerName serverName, +416 final CloseRegionRequest request) throws IOException { +417 try { +418 return getRsAdmin().closeRegion(null, request); +419 } catch (ServiceException se) { +420 throw ProtobufUtil.getRemoteException(se); +421 } +422 } +423 +424 private void remoteCallCompleted(final MasterProcedureEnv env, +425 final CloseRegionResponse response) { +426 operation.setClosed(response.getClosed()); +427 operation.getRemoteProcedure().remoteCallCompleted(env, getServerName(), operation); +428 } +429 +430 private void remoteCallFailed(final MasterProcedureEnv env, final IOException e) { +431 operation.getRemoteProcedure().remoteCallFailed(env, getServerName(), e); +432 } +433 } +434 +435 protected class CompatRemoteProcedureResolver implements Callable<Void>, RemoteProcedureResolver { +436 private final Set<RemoteProcedure> operations; +437 private final ServerName serverName; +438 +439 public CompatRemoteProcedureResolver(final ServerName serverName, +440 final Set<RemoteProcedure> operations) { +441 this.serverName = serverName; +442 this.operations = operations; +443 } +444 +445 @Override +446 public Void call() { +447 splitAndResolveOperation(serverName, operations, this); +448 return null; +449 } +450 +451 public void dispatchOpenRequests(final MasterProcedureEnv env, +452 final List<RegionOpenOperation> operations) { +453 submitTask(new OpenRegionRemoteCall(serverName, operations)); +454 } +455 +456 public void dispatchCloseRequests(final MasterProcedureEnv env, +457 final List<RegionCloseOperation> operations) { +458 for (RegionCloseOperation op: operations) { +459 submitTask(new CloseRegionRemoteCall(serverName, op)); +460 } +461 } +462 } +463 +464 // ========================================================================== +465 // RPC Messages +466 // - ServerOperation: refreshConfig, grant, revoke, ... +467 // - RegionOperation: open, close, flush, snapshot, ... +468 // ========================================================================== +469 public static abstract class ServerOperation extends RemoteOperation { +470 protected ServerOperation(final RemoteProcedure remoteProcedure) { +471 super(remoteProcedure); +472 } +473 } 474 -475 protected RegionOperation(final RemoteProcedure remoteProcedure, -476 final HRegionInfo regionInfo) { -477 super(remoteProcedure); -478 this.regionInfo = regionInfo; -479 } -480 -481 public HRegionInfo getRegionInfo() { -482 return this.regionInfo; -483 } -484 } -485 -486 public static class RegionOpenOperation extends RegionOperation { -487 private final List<ServerName> favoredNodes; -488 private final boolean openForReplay; -489 private boolean failedOpen; -490 -491 public RegionOpenOperation(final RemoteProcedure remoteProcedure, -492 final HRegionInfo regionInfo, final List<ServerName> favoredNodes, -493 final boolean openForReplay) { -494 super(remoteProcedure, regionInfo); -495 this.favoredNodes = favoredNodes; -496 this.openForReplay = openForReplay; -497 } -498 -499 protected void setFailedOpen(final boolean failedOpen) { -500 this.failedOpen = failedOpen; -501 } -502 -503 public boolean isFailedOpen() { -504 return failedOpen; -505 } -506 -507 public OpenRegionRequest.RegionOpenInfo buildRegionOpenInfoRequest( -508 final MasterProcedureEnv env) { -509 return RequestConverter.buildRegionOpenInfo(getRegionInfo(), -510 env.getAssignmentManager().getFavoredNodes(getRegionInfo()), false); -511 } -512 } -513 -514 public static class RegionCloseOperation extends RegionOperation { -515 private final ServerName destinationServer; -516 private boolean closed = false; -517 -518 public RegionCloseOperation(final RemoteProcedure remoteProcedure, -519 final HRegionInfo regionInfo, final ServerName destinationServer) { -520 super(remoteProcedure, regionInfo); -521 this.destinationServer = destinationServer; -522 } -523 -524 public ServerName getDestinationServer() { -525 return destinationServer; -526 } -527 -528 protected void setClosed(final boolean closed) { -529 this.closed = closed; -530 } -531 -532 public boolean isClosed() { -533 return closed; -534 } -535 -536 public CloseRegionRequest buildCloseRegionRequest(final ServerName serverName) { -537 return ProtobufUtil.buildCloseRegionRequest(serverName, -538 getRegionInfo().getRegionName(), getDestinationServer()); -539 } -540 } -541} +475 public static abstract class RegionOperation extends RemoteOperation { +476 private final HRegionInfo regionInfo; +477 +478 protected RegionOperation(final RemoteProcedure remoteProcedure, +479 final HRegionInfo regionInfo) { +480 super(remoteProcedure); +481 this.regionInfo = regionInfo; +482 } +483 +484 public HRegionInfo getRegionInfo() { +485 return this.regionInfo; +486 } +487 } +488 +489 public static class RegionOpenOperation extends RegionOperation { +490 private final List<ServerName> favoredNodes; +491 private final boolean openForReplay; +492 private boolean failedOpen; +493 +494 public RegionOpenOperation(final RemoteProcedure remoteProcedure, +495 final HRegionInfo regionInfo, final List<ServerName> favoredNodes, +496 final boolean openForReplay) { +497 super(remoteProcedure, regionInfo); +498 this.favoredNodes = favoredNodes; +499 this.openForReplay = openForReplay; +500 } +501 +502 protected void setFailedOpen(final boolean failedOpen) { +503 this.failedOpen = failedOpen; +504 } +505 +506 public boolean isFailedOpen() { +507 return failedOpen; +508 } +509 +510 public OpenRegionRequest.RegionOpenInfo buildRegionOpenInfoRequest( +511 final MasterProcedureEnv env) { +512 return RequestConverter.buildRegionOpenInfo(getRegionInfo(), +513 env.getAssignmentManager().getFavoredNodes(getRegionInfo()), false); +514 } +515 } +516 +517 public static class RegionCloseOperation extends RegionOperation { +518 private final ServerName destinationServer; +519 private boolean closed = false; +520 +521 public RegionCloseOperation(final RemoteProcedure remoteProcedure, +522 final HRegionInfo regionInfo, final ServerName destinationServer) { +523 super(remoteProcedure, regionInfo); +524 this.destinationServer = destinationServer; +525 } +526 +527 public ServerName getDestinationServer() { +528 return destinationServer; +529 } +530 +531 protected void setClosed(final boolean closed) { +532 this.closed = closed; +533 } +534 +535 public boolean isClosed() { +536 return closed; +537 } +538 +539 public CloseRegionRequest buildCloseRegionRequest(final ServerName serverName) { +540 return ProtobufUtil.buildCloseRegionRequest(serverName, +541 getRegionInfo().getRegionName(), getDestinationServer()); +542 } +543 } +544}