io.grpc.Status#OK源码实例Demo

@Test
public void internalPickerComparisons() {
  EmptyPicker emptyOk1 = new EmptyPicker(Status.OK);
  EmptyPicker emptyOk2 = new EmptyPicker(Status.OK.withDescription("different OK"));
  EmptyPicker emptyErr = new EmptyPicker(Status.UNKNOWN.withDescription("¯\\_(ツ)_//¯"));

  Iterator<Subchannel> subchannelIterator = subchannels.values().iterator();
  Subchannel sc1 = subchannelIterator.next();
  Subchannel sc2 = subchannelIterator.next();
  StickinessState stickinessState = new StickinessState("stick-key");
  ReadyPicker ready1 = new ReadyPicker(Arrays.asList(sc1, sc2), 0, null);
  ReadyPicker ready2 = new ReadyPicker(Arrays.asList(sc1), 0, null);
  ReadyPicker ready3 = new ReadyPicker(Arrays.asList(sc2, sc1), 1, null);
  ReadyPicker ready4 = new ReadyPicker(Arrays.asList(sc1, sc2), 1, stickinessState);
  ReadyPicker ready5 = new ReadyPicker(Arrays.asList(sc2, sc1), 0, stickinessState);

  assertTrue(emptyOk1.isEquivalentTo(emptyOk2));
  assertFalse(emptyOk1.isEquivalentTo(emptyErr));
  assertFalse(ready1.isEquivalentTo(ready2));
  assertTrue(ready1.isEquivalentTo(ready3));
  assertFalse(ready3.isEquivalentTo(ready4));
  assertTrue(ready4.isEquivalentTo(ready5));
  assertFalse(emptyOk1.isEquivalentTo(ready1));
  assertFalse(ready1.isEquivalentTo(emptyOk1));
}
 

@Test
public void unaryBlockingCallSuccess() throws Exception {
  Integer req = 2;
  final String resp = "bar";
  final Status status = Status.OK;
  final Metadata trailers = new Metadata();

  NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>() {
    @Override
    public void start(ClientCall.Listener<String> listener, Metadata headers) {
      listener.onMessage(resp);
      listener.onClose(status, trailers);
    }
  };

  String actualResponse = ClientCalls.blockingUnaryCall(call, req);
  assertEquals(resp, actualResponse);
}
 

synchronized void onComplete(@javax.annotation.Nullable Throwable error) {
  if (isCompleted()) {
    return;
  }
  currentConfigObserver = null;
  // TODO(songya): add Runnable
  Status status;
  if (error == null) {
    status = Status.OK;
  } else if (error instanceof StatusRuntimeException) {
    status = ((StatusRuntimeException) error).getStatus();
  } else {
    status = Status.UNKNOWN;
  }
  terminateStatus = status;
}
 

private ComputeEngineChannelBuilder(String target) {
  delegate = NettyChannelBuilder.forTarget(target);
  SslContext sslContext;
  try {
    sslContext = GrpcSslContexts.forClient().build();
  } catch (SSLException e) {
    throw new RuntimeException(e);
  }
  InternalNettyChannelBuilder.setProtocolNegotiatorFactory(
      delegate(),
      new GoogleDefaultProtocolNegotiatorFactory(
          /* targetServiceAccounts= */ ImmutableList.<String>of(),
          SharedResourcePool.forResource(HandshakerServiceChannel.SHARED_HANDSHAKER_CHANNEL),
          sslContext));
  CallCredentials credentials = MoreCallCredentials.from(ComputeEngineCredentials.create());
  Status status = Status.OK;
  if (!CheckGcpEnvironment.isOnGcp()) {
    status =
        Status.INTERNAL.withDescription(
            "Compute Engine Credentials can only be used on Google Cloud Platform");
  }
  delegate().intercept(new CallCredentialsInterceptor(credentials, status));
}
 

@Test
public void internalPickerComparisons() {
  EmptyPicker emptyOk1 = new EmptyPicker(Status.OK);
  EmptyPicker emptyOk2 = new EmptyPicker(Status.OK.withDescription("different OK"));
  EmptyPicker emptyErr = new EmptyPicker(Status.UNKNOWN.withDescription("¯\\_(ツ)_//¯"));

  Iterator<Subchannel> subchannelIterator = subchannels.values().iterator();
  Subchannel sc1 = subchannelIterator.next();
  Subchannel sc2 = subchannelIterator.next();
  ReadyPicker ready1 = new ReadyPicker(Arrays.asList(sc1, sc2), 0);
  ReadyPicker ready2 = new ReadyPicker(Arrays.asList(sc1), 0);
  ReadyPicker ready3 = new ReadyPicker(Arrays.asList(sc2, sc1), 1);
  ReadyPicker ready4 = new ReadyPicker(Arrays.asList(sc1, sc2), 1);
  ReadyPicker ready5 = new ReadyPicker(Arrays.asList(sc2, sc1), 0);

  assertTrue(emptyOk1.isEquivalentTo(emptyOk2));
  assertFalse(emptyOk1.isEquivalentTo(emptyErr));
  assertFalse(ready1.isEquivalentTo(ready2));
  assertTrue(ready1.isEquivalentTo(ready3));
  assertTrue(ready3.isEquivalentTo(ready4));
  assertTrue(ready4.isEquivalentTo(ready5));
  assertFalse(emptyOk1.isEquivalentTo(ready1));
  assertFalse(ready1.isEquivalentTo(emptyOk1));
}
 

@Test
public void unaryBlockingCallSuccess() throws Exception {
  Integer req = 2;
  final String resp = "bar";
  final Status status = Status.OK;
  final Metadata trailers = new Metadata();

  NoopClientCall<Integer, String> call = new NoopClientCall<Integer, String>() {
    @Override
    public void start(ClientCall.Listener<String> listener, Metadata headers) {
      listener.onMessage(resp);
      listener.onClose(status, trailers);
    }
  };

  String actualResponse = ClientCalls.blockingUnaryCall(call, req);
  assertEquals(resp, actualResponse);
}
 

@Test
public void testNoRetryOnOk() throws IOException {
  String uniqueName = InProcessServerBuilder.generateName();
  ExecutionImpl service = new ExecutionImpl(Status.OK, 0);
  InProcessServerBuilder.forName(uniqueName).addService(service).build().start();
  CallCounter beforeRetry = new CallCounter();
  ManagedChannel channel =
      InProcessChannelBuilder.forName(uniqueName)
          .intercept(
              new RetryClientInterceptor(
                  RetryPolicy.builder().setMaxRetries(2).setBeforeRetry(beforeRetry).build()))
          .build();
  ExecutionBlockingStub stub = ExecutionGrpc.newBlockingStub(channel);
  stub.execute(ExecuteRequest.newBuilder().build()).forEachRemaining(resp -> {});

  Assert.assertEquals(1, service.calls);
  Assert.assertEquals(0, beforeRetry.calls);
}
 

@Override
public ManagedChannel build() {
  @Nullable CallCredentials credentials = null;
  Status status = Status.OK;
  try {
    credentials = MoreCallCredentials.from(GoogleCredentials.getApplicationDefault());
  } catch (IOException e) {
    status =
        Status.UNAUTHENTICATED
            .withDescription("Failed to get Google default credentials")
            .withCause(e);
  }
  return delegate().intercept(new GoogleDefaultInterceptor(credentials, status)).build();
}
 

@Test
public void testStatusOk() {
  final Status status = Status.OK;
  MockSpan span = new MockTracer().buildSpan("").start();
  GrpcTags.GRPC_STATUS.set(span, status);
  assertThat(span.tags())
      .containsExactly(MapEntry.entry(GrpcTags.GRPC_STATUS.getKey(), status.getCode().name()));
}
 

synchronized void onComplete(@javax.annotation.Nullable Throwable error) {
  if (isCompleted()) {
    return;
  }
  // TODO(songya): add Runnable
  Status status;
  if (error == null) {
    status = Status.OK;
  } else if (error instanceof StatusRuntimeException) {
    status = ((StatusRuntimeException) error).getStatus();
  } else {
    status = Status.UNKNOWN;
  }
  terminateStatus = status;
}
 

synchronized void onComplete(@javax.annotation.Nullable Throwable error) {
  if (isCompleted()) {
    return;
  }
  // TODO(songya): add Runnable
  Status status;
  if (error == null) {
    status = Status.OK;
  } else if (error instanceof StatusRuntimeException) {
    status = ((StatusRuntimeException) error).getStatus();
  } else {
    status = Status.UNKNOWN;
  }
  terminateStatus = status;
}
 

private void sendResponse(
    ChannelHandlerContext ctx, int streamId, ByteBuf grpcResponseBuffer, Status status) {
  Headers headers =
      new DefaultHeaders().set(HttpHeaderNames.CONTENT_TYPE, GRPC_CONTENT_TYPE_VALUE);
  DefaultSegmentedResponse segmentedResponse =
      DefaultSegmentedResponse.builder()
          .streamId(streamId)
          .status(HttpResponseStatus.OK)
          .headers(headers)
          .build();

  ctx.writeAndFlush(segmentedResponse);

  Headers trailingHeaders =
      new DefaultHeaders()
          .set(GRPC_TRAILING_HEADER_STATUS_KEY, Integer.toString(status.getCode().value()));

  if (status.getDescription() != null) {
    trailingHeaders.add(
        GRPC_TRAILING_HEADER_MESSAGE_KEY, grpcEncodedString(status.getDescription()));
  }

  DefaultSegmentedData data =
      DefaultSegmentedData.builder()
          .streamId(streamId)
          .content(grpcResponseBuffer)
          .trailingHeaders(trailingHeaders)
          .endOfMessage(true)
          .build();

  ctx.writeAndFlush(data);

  HashMap<Integer, GrpcState> session = lazyCreateSession(ctx);
  session.remove(streamId);

  if (status != Status.OK) {
    ctx.close();
  }
}
 

@Override
public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> serverCall,
    Metadata metadata, ServerCallHandler<ReqT, RespT> serverCallHandler) {
  String value = metadata.get(Constant.AUTHORIZATION_METADATA_KEY);

  Status status = Status.OK;
  if (value == null) {
    status = Status.UNAUTHENTICATED.withDescription("Authorization token is missing");
  } else if (!value.startsWith(Constant.BEARER_TYPE)) {
    status = Status.UNAUTHENTICATED.withDescription("Unknown authorization type");
  } else {
    Jws<Claims> claims = null;
    // remove authorization type prefix
    String token = value.substring(Constant.BEARER_TYPE.length()).trim();
    try {
      // verify token signature and parse claims
      claims = parser.parseClaimsJws(token);
    } catch (JwtException e) {
      status = Status.UNAUTHENTICATED.withDescription(e.getMessage()).withCause(e);
    }
    if (claims != null) {
      // set client id into current context
      Context ctx = Context.current()
          .withValue(Constant.CLIENT_ID_CONTEXT_KEY, claims.getBody().getSubject());
      return Contexts.interceptCall(ctx, serverCall, metadata, serverCallHandler);
    }
  }

  serverCall.close(status, new Metadata());
  return new ServerCall.Listener<ReqT>() {
    // noop
  };
}
 

/**
 * Given a server call, performs client authorization check, i.e., checks if the client service
 * account matches one of the expected service accounts. It returns OK if client is authorized and
 * an error otherwise.
 */
public static Status clientAuthorizationCheck(
    ServerCall<?, ?> call, Collection<String> expectedServiceAccounts) {
  AltsAuthContext altsContext =
      (AltsAuthContext) call.getAttributes().get(AltsProtocolNegotiator.AUTH_CONTEXT_KEY);
  if (altsContext == null) {
    return Status.PERMISSION_DENIED.withDescription("Peer ALTS AuthContext not found");
  }
  if (expectedServiceAccounts.contains(altsContext.getPeerServiceAccount())) {
    return Status.OK;
  }
  return Status.PERMISSION_DENIED.withDescription(
      "Client " + altsContext.getPeerServiceAccount() + " is not authorized");
}
 

private void handleRemoteBuildFailedWithException(Throwable t) {
  remoteBuildResult =
      Optional.of(t instanceof InterruptedException ? Result.INTERRUPTED : Result.EXCEPTION);
  if (t instanceof StepFailedException) {
    StepFailedException exc = (StepFailedException) t;
    exitCode = exc.getExitCode();
    remoteExecutionMetadata = exc.getRemoteExecutionMetadata();
    if (remoteExecutionMetadata.isPresent()) {
      if (remoteExecutionMetadata
          .get()
          .getExecutedActionInfo()
          .hasIsFallbackEnabledForCompletedAction()) {
        localFallbackEnabledForCompletedAction =
            remoteExecutionMetadata
                .get()
                .getExecutedActionInfo()
                .getIsFallbackEnabledForCompletedAction()
                .getValue();
      }
    }
  }
  remoteGrpcStatus = exitCode.isPresent() ? Status.OK : Status.fromThrowable(t);

  if (remoteStrategyBuildResult
      instanceof RemoteExecutionStrategy.RemoteExecutionStrategyBuildResult) {
    lastNonTerminalState =
        ((RemoteExecutionStrategy.RemoteExecutionStrategyBuildResult) remoteStrategyBuildResult)
            .getRuleContext()
            .lastNonTerminalState;
  }

  remoteBuildErrorMessage = Optional.of(t.toString());
  boolean fallbackEnabledForCurrentResult =
      localFallbackEnabled
          && (localFallbackEnabledForCompletedAction || remoteGrpcStatus != Status.OK);
  if (fallbackEnabledForCurrentResult
      && (!localFallbackDisabledOnCorruptedArtifacts
          || !(MultiThreadedBlobUploader.CorruptArtifactException.isCause(
              ThrowableCauseIterable.of(t))))) {
    LOG.warn(
        t, "Remote build failed for a build rule so trying locally now for [%s].", buildTarget);
    fallbackBuildToLocalStrategy();
  } else {
    if (remoteGrpcStatus == Status.OK) {
      eventBus.post(
          ConsoleEvent.severe(
              "The build failed trying to build remotely. This is most likely due to a missing dependency"
              ));
    }
    completeCombinedFutureWithException(t, remoteBuildResult.get(), Result.NOT_RUN);
  }
}
 

@Test public void errorCode_nullWhenOk() {
  status = Status.OK;
  GrpcClientResponse response = new GrpcClientResponse(request, headers, status, trailers);

  assertThat(response.errorCode()).isNull();
}
 

@Test public void errorCode_nullWhenOk() {
  status = Status.OK;
  GrpcServerResponse response = new GrpcServerResponse(request, headers, status, trailers);

  assertThat(response.errorCode()).isNull();
}