com.google.protobuf.FieldMask#com.google.protobuf.Any源码实例Demo

static SocketOption toSocketOptionLinger(int lingerSeconds) {
  final SocketOptionLinger lingerOpt;
  if (lingerSeconds >= 0) {
    lingerOpt = SocketOptionLinger
        .newBuilder()
        .setActive(true)
        .setDuration(Durations.fromSeconds(lingerSeconds))
        .build();
  } else {
    lingerOpt = SocketOptionLinger.getDefaultInstance();
  }
  return SocketOption
      .newBuilder()
      .setName(SO_LINGER)
      .setAdditional(Any.pack(lingerOpt))
      .build();
}
 

@Test
public void stateIsModified() {
  functionUnderTest.invoke(context, Any.getDefaultInstance());

  // A message returned from the function
  // that asks to put "hello" into the session state.
  FromFunction response =
      FromFunction.newBuilder()
          .setInvocationResult(
              InvocationResponse.newBuilder()
                  .addStateMutations(
                      PersistedValueMutation.newBuilder()
                          .setStateValue(ByteString.copyFromUtf8("hello"))
                          .setMutationType(MutationType.MODIFY)
                          .setStateName("session")))
          .build();

  functionUnderTest.invoke(context, successfulAsyncOperation(response));

  functionUnderTest.invoke(context, Any.getDefaultInstance());
  assertThat(client.capturedState(0), is(ByteString.copyFromUtf8("hello")));
}
 

@Override
public void enterListLput(DistkvNewSQLParser.ListLputContext ctx) {
  Preconditions.checkState(parsedResult == null);
  Preconditions.checkState(ctx.children.size() == 3);
  ListProtocol.ListLPutRequest.Builder builder = ListProtocol.ListLPutRequest.newBuilder();
  final int valueSize = ctx.children.get(2).getChildCount();
  for (int i = 0; i < valueSize; ++i) {
    builder.addValues(ctx.children.get(2).getChild(i).getText());
  }
  DistkvRequest request = DistkvRequest.newBuilder()
      .setKey(ctx.children.get(1).getText())
      .setRequestType(LIST_LPUT)
      .setRequest(Any.pack(builder.build()))
      .build();
  parsedResult = new DistkvParsedResult(LIST_LPUT, request);
}
 

private static void testRemoveItem(int rpcServerPort) {
  try (ProxyOnClient<DistkvService> setProxy = new ProxyOnClient<>(
      DistkvService.class, rpcServerPort)) {
    DistkvService setService = setProxy.getService();
    SetProtocol.SetRemoveItemRequest.Builder setRemoveRequestBuilder =
        SetProtocol.SetRemoveItemRequest.newBuilder();
    setRemoveRequestBuilder.setItemValue("v1");
    DistkvRequest request = DistkvRequest.newBuilder()
        .setKey("k1")
        .setRequestType(RequestType.SET_REMOVE_ITEM)
        .setRequest(Any.pack(setRemoveRequestBuilder.build()))
        .build();
    DistkvResponse setDeleteResponse = FutureUtils.get(
        setService.call(request));
    Assert.assertEquals(CommonProtocol.Status.OK, setDeleteResponse.getStatus());
  }
}
 

@Override
public Any deserialize(JsonParser p, DeserializationContext ctxt)
        throws IOException, JsonProcessingException {
    JsonNode root = p.getCodec().readTree(p);
    JsonNode type = root.get(JSON_TYPE);
    JsonNode value = root.get(JSON_VALUE);

    if (type == null || !type.isTextual()) {
        ctxt.reportMappingException("invalid '@type' field when deserializing ProtoBuf Any object");
    }

    if (value == null || !value.isTextual()) {
        ctxt.reportMappingException("invalid '@value' field when deserializing ProtoBuf Any object");
    }

    return Any.newBuilder()
            .setTypeUrl(type.textValue())
            .setValue(ByteString.copyFrom(value.binaryValue()))
            .build();
}
 

@Override
public void enterDictPut(DistkvNewSQLParser.DictPutContext ctx) {
  Preconditions.checkState(parsedResult == null);
  Preconditions.checkState(ctx.children.size() == 3);
  DictProtocol.DictPutRequest.Builder builder = DictProtocol.DictPutRequest.newBuilder();
  final ParseTree keyValuePairsParseTree = ctx.children.get(2);
  final int numKeyValuePairs = keyValuePairsParseTree.getChildCount();
  DictProtocol.DistKVDict.Builder distKVDictBuilder = DictProtocol.DistKVDict.newBuilder();
  for (int i = 0; i < numKeyValuePairs; ++i) {
    final ParseTree keyValuePairParseTree = keyValuePairsParseTree.getChild(i);
    Preconditions.checkState(keyValuePairParseTree.getChildCount() == 2);
    distKVDictBuilder.addKeys(keyValuePairParseTree.getChild(0).getText());
    distKVDictBuilder.addValues(keyValuePairParseTree.getChild(1).getText());
  }
  builder.setDict(distKVDictBuilder.build());
  DistkvRequest request = DistkvRequest.newBuilder()
      .setKey(ctx.children.get(1).getText())
      .setRequestType(DICT_PUT)
      .setRequest(Any.pack(builder.build()))
      .build();
  parsedResult = new DistkvParsedResult(DICT_PUT, request);
}
 

public static byte[] getToAddress(Transaction.Contract contract) {
    ByteString to;
    try {
        Any contractParameter = contract.getParameter();
        switch (contract.getType()) {
            case TransferAssetContract:
                to = contractParameter.unpack(TransferAssetContract.class).getToAddress();
                break;
            case TransferContract:
                to = contractParameter.unpack(TransferContract.class).getToAddress();
                break;
            case ParticipateAssetIssueContract:
                to = contractParameter.unpack(ParticipateAssetIssueContract.class).getToAddress();
                break;
            // todo add other contract

            default:
                return null;
        }
        return to.toByteArray();
    } catch (Exception ex) {
        logger.error(ex.getMessage());
        return null;
    }
}
 

@Override
public void enterSlistTop(DistkvNewSQLParser.SlistTopContext ctx) {
  Preconditions.checkState(parsedResult == null);
  Preconditions.checkState(ctx.children.size() == 3);

  SlistProtocol.SlistTopRequest.Builder slistTopRequestBuilder =
      SlistProtocol.SlistTopRequest.newBuilder();
  slistTopRequestBuilder.setCount(Integer.parseInt(ctx.children.get(2).getText()));
  DistkvRequest request = DistkvRequest.newBuilder()
      .setKey(ctx.children.get(1).getText())
      .setRequestType(SLIST_TOP)
      .setRequest(Any.pack(slistTopRequestBuilder.build()))
      .build();
  parsedResult = new DistkvParsedResult(
      SLIST_TOP, request);
}
 

/** {@inheritDoc} */
@Override
public Object fromProto(@NonNull MessageLite messageLite) {
  checkNotNull(messageLite, "messageLite cannot be null!");
  try {
    RemoteDescriptor remoteDescriptor =
        messageLite instanceof Any
            // For Any protos get the remote through the type url
            ? remoteDescriptorRegistry.argForRemoteTypeUrl(((Any) messageLite).getTypeUrl())
            // For All other msg types get remote type descriptor for proto message "runtime" type
            : remoteDescriptorRegistry.argForMsgType(messageLite.getClass());
    return fromProtoInternal(messageLite, remoteDescriptor);
  } catch (Exception e) {
    if (e.getCause() instanceof RemoteProtocolException) {
      throw (RemoteProtocolException) e;
    }
    throw new RemoteProtocolException("Error: " + e.getMessage(), e);
  }
}
 

/**
 * Builds the object io.dapr.{@link DaprProtos.InvokeServiceRequest} to be send based on the parameters.
 *
 * @param verb    String that must match HTTP Methods
 * @param appId   The application id to be invoked
 * @param method  The application method to be invoked
 * @param request The body of the request to be send as part of the invokation
 * @param <K>     The Type of the Body
 * @return The object to be sent as part of the invokation.
 * @throws IOException If there's an issue serializing the request.
 */
private <K> DaprProtos.InvokeServiceRequest buildInvokeServiceRequest(
    String verb, String appId, String method, K request) throws IOException {
  CommonProtos.InvokeRequest.Builder requestBuilder = CommonProtos.InvokeRequest.newBuilder();
  requestBuilder.setMethod(method);
  if (request != null) {
    byte[] byteRequest = objectSerializer.serialize(request);
    Any data = Any.newBuilder().setValue(ByteString.copyFrom(byteRequest)).build();
    requestBuilder.setData(data);
  } else {
    requestBuilder.setData(Any.newBuilder().build());
  }

  CommonProtos.HTTPExtension.Builder httpExtensionBuilder = CommonProtos.HTTPExtension.newBuilder();
  if ((verb != null) && !verb.isEmpty()) {
    httpExtensionBuilder.setVerb(CommonProtos.HTTPExtension.Verb.valueOf(verb.toUpperCase()));
  } else {
    httpExtensionBuilder.setVerb(CommonProtos.HTTPExtension.Verb.NONE);
  }
  requestBuilder.setHttpExtension(httpExtensionBuilder.build());

  DaprProtos.InvokeServiceRequest.Builder envelopeBuilder = DaprProtos.InvokeServiceRequest.newBuilder()
      .setId(appId)
      .setMessage(requestBuilder.build());
  return envelopeBuilder.build();
}
 

/**
 * If so throws an error if the workspace type is USER and the workspaceId and userID do not
 * match. Is a NO-OP if userinfo is null.
 */
public static void checkPersonalWorkspace(
    UserInfo userInfo,
    WorkspaceType workspaceType,
    String workspaceId,
    String resourceNameString) {
  if (userInfo != null
      && workspaceType == WorkspaceType.USER
      && !workspaceId.equals(userInfo.getVertaInfo().getUserId())) {
    Status status =
        Status.newBuilder()
            .setCode(Code.PERMISSION_DENIED_VALUE)
            .setMessage(
                "Creation of "
                    + resourceNameString
                    + " in other user's workspace is not permitted")
            .addDetails(Any.pack(UpdateProjectName.Response.getDefaultInstance()))
            .build();
    throw StatusProto.toStatusRuntimeException(status);
  }
}
 

@Test 
public void testRequestToJSON() throws JsonParseException, IOException, NoSuchMethodException, SecurityException
{
	mockClientConfigHandler.addListener((ClientConfigUpdateListener) EasyMock.anyObject());
	EasyMock.expectLastCall().once();
	replay(mockClientConfigHandler);
	final String client = "test";
	ClientRpcStore store = new ClientRpcStore(mockClientConfigHandler);
	CustomPredictRequest customRequest =  CustomPredictRequest.newBuilder().addData(1.0f).build();
	store.add(client, customRequest.getClass(), null,customRequest.getClass().getMethod("newBuilder"),null);
	Any anyMsg = Any.pack(customRequest);
	ClassificationRequestMeta meta = ClassificationRequestMeta.newBuilder().setPuid("1234").build();
	ClassificationRequest request = ClassificationRequest.newBuilder().setMeta(meta).setData(anyMsg).build();
	JsonNode json = store.getJSONForRequest(client, request);
	Assert.assertNotNull(json);
	System.out.println(json);
	ObjectMapper mapper = new ObjectMapper();
    JsonFactory factory = mapper.getFactory();
    JsonParser parser = factory.createParser(json.toString());
    JsonNode actualObj = mapper.readTree(parser);
    ClassificationRequest req = store.getPredictRequestFromJson(client, actualObj);
    Assert.assertNotNull(req);
}
 

private Any getContract(String address, ByteString url) {
  return Any.pack(
      Contract.WitnessCreateContract.newBuilder()
          .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(address)))
          .setUrl(url)
          .build());
}
 

static Security toSecurity(InternalChannelz.Security security) {
  Preconditions.checkNotNull(security);
  Preconditions.checkState(
      security.tls != null ^ security.other != null,
      "one of tls or othersecurity must be non null");
  if (security.tls != null) {
    Tls.Builder tlsBuilder
        = Tls.newBuilder().setStandardName(security.tls.cipherSuiteStandardName);
    try {
      if (security.tls.localCert != null) {
        tlsBuilder.setLocalCertificate(ByteString.copyFrom(
            security.tls.localCert.getEncoded()));
      }
      if (security.tls.remoteCert != null) {
        tlsBuilder.setRemoteCertificate(ByteString.copyFrom(
            security.tls.remoteCert.getEncoded()));
      }
    } catch (CertificateEncodingException e) {
      logger.log(Level.FINE, "Caught exception", e);
    }
    return Security.newBuilder().setTls(tlsBuilder).build();
  } else {
    OtherSecurity.Builder builder = OtherSecurity.newBuilder().setName(security.other.name);
    if (security.other.any != null) {
      builder.setValue((Any) security.other.any);
    }
    return Security.newBuilder().setOther(builder).build();
  }
}
 

@Override
public void deleteExperimentRun(
    DeleteExperimentRun request, StreamObserver<DeleteExperimentRun.Response> responseObserver) {
  QPSCountResource.inc();
  try (RequestLatencyResource latencyResource =
      new RequestLatencyResource(ModelDBAuthInterceptor.METHOD_NAME.get())) {
    if (request.getId().isEmpty()) {
      String errorMessage = "ExperimentRun ID not found in DeleteExperimentRun request";
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder()
              .setCode(Code.INVALID_ARGUMENT_VALUE)
              .setMessage(errorMessage)
              .addDetails(Any.pack(DeleteExperiment.Response.getDefaultInstance()))
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }

    boolean deleteStatus =
        experimentRunDAO.deleteExperimentRuns(Collections.singletonList(request.getId()));

    responseObserver.onNext(
        DeleteExperimentRun.Response.newBuilder().setStatus(deleteStatus).build());
    responseObserver.onCompleted();

  } catch (Exception e) {
    ModelDBUtils.observeError(
        responseObserver, e, DeleteExperimentRun.Response.getDefaultInstance());
  }
}
 

@Override
public Object deserialize(@Nonnull ClassLoader targetClassLoader, @Nonnull Payload payload) {
  return Any.newBuilder()
      .setTypeUrl(payload.getClassName())
      .setValue(payload.getPayloadBytes())
      .build();
}
 

@Test
public void testEgresses() {
  StatefulFunctionModule module = fromPath(modulePath);

  StatefulFunctionsUniverse universe = emptyUniverse();
  module.configure(Collections.emptyMap(), universe);

  assertThat(
      universe.egress(), hasKey(new EgressIdentifier<>("com.mycomp.foo", "bar", Any.class)));
}
 

@Override
public Object deserialize(@Nonnull ClassLoader targetClassLoader, @Nonnull Payload payload) {
  return Any.newBuilder()
      .setTypeUrl(payload.getClassName())
      .setValue(payload.getPayloadBytes())
      .build();
}
 

@Override
public void enterStrPut(DistkvNewSQLParser.StrPutContext ctx) {
  Preconditions.checkState(parsedResult == null);
  Preconditions.checkState(ctx.children.size() == 3);

  StringProtocol.StrPutRequest.Builder builder = StringProtocol.StrPutRequest.newBuilder();
  builder.setValue(ctx.children.get(2).getText());
  DistkvRequest request = DistkvRequest.newBuilder()
      .setKey(ctx.children.get(1).getText())
      .setRequestType(STR_PUT)
      .setRequest(Any.pack(builder.build()))
      .build();
  parsedResult = new DistkvParsedResult(STR_PUT, request);
}
 

private Any getContract(ByteString name, String address) {
    return Any.pack(
            Contract.AccountUpdateContract.newBuilder()
                    .setAccountName(name)
                    .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(address)))
                    .build());
}
 

@Test
public void anys_pack() throws IOException {
  builder
      .addAnys(Any.pack(ProtobufRoot.User.newBuilder().setName("n1").build()))
      .addAnys(Any.pack(ProtobufRoot.User.newBuilder().setName("n2").build()));
  check();
}
 

@Override
public void getLabels(
    GetLabelsRequest request, StreamObserver<GetLabelsRequest.Response> responseObserver) {
  QPSCountResource.inc();
  try (RequestLatencyResource latencyResource =
      new RequestLatencyResource(ModelDBAuthInterceptor.METHOD_NAME.get())) {

    if (request.getId() == null
        || request.getId().getIdTypeValue() == 0
        || (request.getId().getIntId() == 0 && request.getId().getStringId().isEmpty())) {
      String errorMessage = "Invalid parameter set in GetLabelsRequest.Id";
      LOGGER.info(errorMessage);
      Status status =
          Status.newBuilder()
              .setCode(Code.INVALID_ARGUMENT_VALUE)
              .setMessage(errorMessage)
              .addDetails(Any.pack(GetLabelsRequest.Response.getDefaultInstance()))
              .build();
      throw StatusProto.toStatusRuntimeException(status);
    }

    List<String> labels = metadataDAO.getLabels(request.getId());
    responseObserver.onNext(GetLabelsRequest.Response.newBuilder().addAllLabels(labels).build());
    responseObserver.onCompleted();
  } catch (Exception e) {
    ModelDBUtils.observeError(
        responseObserver, e, GetLabelsRequest.Response.getDefaultInstance());
  }
}
 

static SocketOption toSocketOptionTimeout(String name, int timeoutMillis) {
  Preconditions.checkNotNull(name);
  return SocketOption
      .newBuilder()
      .setName(name)
      .setAdditional(
          Any.pack(
              SocketOptionTimeout
                  .newBuilder()
                  .setDuration(Durations.fromMillis(timeoutMillis))
                  .build()))
      .build();
}
 

@Test
@SuppressWarnings("all")
public void createCampaignExperimentTest2() throws Exception {
  Empty expectedResponse = Empty.newBuilder().build();
  Operation resultOperation =
      Operation.newBuilder()
          .setName("createCampaignExperimentTest2")
          .setDone(true)
          .setResponse(Any.pack(expectedResponse))
          .build();
  mockCampaignExperimentService.addResponse(resultOperation);

  String customerId = "customerId-1772061412";
  CampaignExperiment campaignExperiment = CampaignExperiment.newBuilder().build();

  Empty actualResponse =
      client.createCampaignExperimentAsync(customerId, campaignExperiment).get();
  Assert.assertEquals(expectedResponse, actualResponse);

  List<AbstractMessage> actualRequests = mockCampaignExperimentService.getRequests();
  Assert.assertEquals(1, actualRequests.size());
  CreateCampaignExperimentRequest actualRequest =
      (CreateCampaignExperimentRequest) actualRequests.get(0);

  Assert.assertEquals(customerId, actualRequest.getCustomerId());
  Assert.assertEquals(campaignExperiment, actualRequest.getCampaignExperiment());
  Assert.assertTrue(
      channelProvider.isHeaderSent(
          ApiClientHeaderProvider.getDefaultApiClientHeaderKey(),
          GaxGrpcProperties.getDefaultApiClientHeaderPattern()));
}
 

@Test
public void example() {
  functionUnderTest.invoke(context, Any.getDefaultInstance());

  assertTrue(client.wasSentToFunction.hasInvocation());
  assertThat(client.capturedInvocationBatchSize(), is(1));
}
 

@Test
public void noMetricsConfiguredTest() {
  Operation operation =
      defaultOperation.toBuilder().setResponse(Any.pack(defaultExecuteResponse)).build();

  assertThat(
          new LogMetricsPublisher(MetricsConfig.getDefaultInstance())
              .populateRequestMetadata(operation, defaultRequestMetadata))
      .isNotNull();
}
 

public static void checkPreconditionFailure(
    Digest actionDigest, PreconditionFailure preconditionFailure) throws StatusException {
  if (preconditionFailure.getViolationsCount() != 0) {
    throw StatusProto.toStatusException(
        Status.newBuilder()
            .setCode(Code.FAILED_PRECONDITION.getNumber())
            .setMessage(invalidActionVerboseMessage(actionDigest, preconditionFailure))
            .addDetails(Any.pack(preconditionFailure))
            .build());
  }
}
 

private void logAndThrowError(String errorMessage, int errorCode, Any defaultResponse) {
  LOGGER.warn(errorMessage);
  Status status =
      Status.newBuilder()
          .setCode(errorCode)
          .setMessage(errorMessage)
          .addDetails(defaultResponse)
          .build();
  throw StatusProto.toStatusRuntimeException(status);
}
 

private Any getContractWithTo(long count, String toAddress) {
  String assertName = ASSET_NAME;
  if (dbManager.getDynamicPropertiesStore().getAllowSameTokenName() == 1) {
    long tokenIdNum = dbManager.getDynamicPropertiesStore().getTokenIdNum();
    assertName = String.valueOf(tokenIdNum);
  }
  return Any.pack(
      Contract.ParticipateAssetIssueContract.newBuilder()
          .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS)))
          .setToAddress(ByteString.copyFrom(ByteArray.fromHexString(toAddress)))
          .setAssetName(ByteString.copyFrom(ByteArray.fromString(assertName)))
          .setAmount(count)
          .build());
}
 

private Any getContract(long sendCoin, ByteString assetName) {
  return Any.pack(
      Contract.TransferAssetContract.newBuilder()
          .setAssetName(assetName)
          .setOwnerAddress(ByteString.copyFrom(ByteArray.fromHexString(OWNER_ADDRESS)))
          .setToAddress(ByteString.copyFrom(ByteArray.fromHexString(TO_ADDRESS)))
          .setAmount(sendCoin)
          .build());
}