Java Empty类代码示例

import com.google.protobuf.Empty; //导入依赖的package包/类
@Test
public void clientCanCancelServerStreamExplicitly() throws InterruptedException {
    AtomicInteger lastNumberConsumed = new AtomicInteger(Integer.MAX_VALUE);
    ReactorNumbersGrpc.ReactorNumbersStub stub = ReactorNumbersGrpc.newReactorStub(channel);
    Flux<NumberProto.Number> test = stub
            .responsePressure(Mono.just(Empty.getDefaultInstance()))
            .doOnNext(number -> {lastNumberConsumed.set(number.getNumber(0)); System.out.println("C: " + number.getNumber(0));})
            .doOnError(throwable -> System.out.println(throwable.getMessage()))
            .doOnComplete(() -> System.out.println("Completed"))
            .doOnCancel(() -> System.out.println("Client canceled"));

    Disposable subscription = test.publish().connect();

    Thread.sleep(1000);
    subscription.dispose();
    Thread.sleep(1000);

    // Cancellation may or may not deliver the last generated message due to delays in the gRPC processing thread
    assertThat(Math.abs(lastNumberConsumed.get() - svc.getLastNumberProduced())).isLessThanOrEqualTo(3);
    assertThat(svc.wasCanceled()).isTrue();
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Test
public void clientCanCancelServerStreamExplicitly() throws InterruptedException {
    RxNumbersGrpc.RxNumbersStub stub = RxNumbersGrpc.newRxStub(channel);
    TestSubscriber<NumberProto.Number> subscription = stub
            .responsePressure(Single.just(Empty.getDefaultInstance()))
            .doOnNext(number -> System.out.println(number.getNumber(0)))
            .doOnError(throwable -> System.out.println(throwable.getMessage()))
            .doOnComplete(() -> System.out.println("Completed"))
            .doOnCancel(() -> System.out.println("Client canceled"))
            .test();

    Thread.sleep(250);
    subscription.dispose();
    Thread.sleep(250);

    subscription.awaitTerminalEvent(3, TimeUnit.SECONDS);
    // Cancellation may or may not deliver the last generated message due to delays in the gRPC processing thread
    assertThat(Math.abs(subscription.valueCount() - svc.getLastNumberProduced())).isLessThanOrEqualTo(3);
    assertThat(svc.wasCanceled()).isTrue();
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Test
public void clientCanCancelServerStreamImplicitly() throws InterruptedException {
    RxNumbersGrpc.RxNumbersStub stub = RxNumbersGrpc.newRxStub(channel);
    TestSubscriber<NumberProto.Number> subscription = stub
            .responsePressure(Single.just(Empty.getDefaultInstance()))
            .doOnNext(number -> System.out.println(number.getNumber(0)))
            .doOnError(throwable -> System.out.println(throwable.getMessage()))
            .doOnComplete(() -> System.out.println("Completed"))
            .doOnCancel(() -> System.out.println("Client canceled"))
            .take(10)
            .test();

    // Consume some work
    Thread.sleep(TimeUnit.SECONDS.toMillis(1));
    subscription.dispose();

    subscription.awaitTerminalEvent(3, TimeUnit.SECONDS);
    subscription.assertValueCount(10);
    subscription.assertTerminated();
    assertThat(svc.wasCanceled()).isTrue();
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Test
public void serverToClientBackpressure() throws InterruptedException {
    RxNumbersGrpc.RxNumbersStub stub = RxNumbersGrpc.newRxStub(channel);

    Single<Empty> rxRequest = Single.just(Empty.getDefaultInstance());

    TestSubscriber<NumberProto.Number> rxResponse = stub.responsePressure(rxRequest)
            .doOnNext(n -> System.out.println(n.getNumber(0) + "  <--"))
            .doOnNext(n -> waitIfValuesAreEqual(n.getNumber(0), 3))
            .test();

    rxResponse.awaitTerminalEvent(5, TimeUnit.SECONDS);
    rxResponse.assertComplete()
            .assertValueCount(NUMBER_OF_STREAM_ELEMENTS);

    assertThat(numberOfWaits.get()).isEqualTo(1);
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Test
public void clientCanCancelServerStreamImplicitly() throws InterruptedException {
    ReactorNumbersGrpc.ReactorNumbersStub stub = ReactorNumbersGrpc.newReactorStub(channel);
    Flux<NumberProto.Number> test = stub
            .responsePressure(Mono.just(Empty.getDefaultInstance()))
            .doOnNext(number -> System.out.println(number.getNumber(0)))
            .doOnError(throwable -> System.out.println(throwable.getMessage()))
            .doOnComplete(() -> System.out.println("Completed"))
            .doOnCancel(() -> System.out.println("Client canceled"))
            .take(10);

    Disposable subscription = test.publish().connect();

    Thread.sleep(1000);

    assertThat(svc.wasCanceled()).isTrue();
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Test
public void serverToClientBackpressure() throws InterruptedException {
    ReactorNumbersGrpc.ReactorNumbersStub stub = ReactorNumbersGrpc.newReactorStub(channel);

    Mono<Empty> reactorRequest = Mono.just(Empty.getDefaultInstance());

    Flux<NumberProto.Number> reactorResponse = stub.responsePressure(reactorRequest)
            .doOnNext(n -> System.out.println(n.getNumber(0) + "  <--"))
            .doOnNext(n -> waitIfValuesAreEqual(n.getNumber(0), 3));

    StepVerifier.create(reactorResponse)
            .expectNextCount(NUMBER_OF_STREAM_ELEMENTS)
            .expectComplete()
            .verify(Duration.ofSeconds(5));

    assertThat(numberOfWaits.get()).isEqualTo(1);
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Override
public void flush() {
  List<Span> spans = new ArrayList<>();
  queue.drain(spans::add);
  if (spans.isEmpty()) {
    return;
  }
  PatchTracesRequest request =
      PatchTracesRequest.newBuilder()
          .setProjectId(projectId)
          .setTraces(Traces.newBuilder().addAllTraces(translator.translateSpans(spans)))
          .build();
  ApiFutures.addCallback(
      traceServiceClient.patchTracesCallable().futureCall(request),
      new ApiFutureCallback<Empty>() {
        @Override
        public void onFailure(Throwable t) {
          logger.warn("Error reporting traces.", t);
        }

        @Override
        public void onSuccess(Empty result) {
          logger.info("Successfully reported traces.");
        }
      });
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    String host = args[0];
    int port = Integer.parseInt(args[1]);

    String abstractName = "mesh://timeService";

    // Open a channel to the server
    Channel channel = ManagedChannelBuilder
            .forTarget(abstractName)
            .nameResolverFactory(StaticResolver.factory(new InetSocketAddress(host, port)))
            .usePlaintext(true)
            .build();

    // Create a CompletableFuture-based stub
    TimeServiceGrpc8.TimeServiceCompletableFutureStub stub = TimeServiceGrpc8.newCompletableFutureStub(channel);

    // Call the service
    CompletableFuture<TimeReply> completableFuture = stub.getTime(Empty.getDefaultInstance());
    TimeReply timeReply = completableFuture.get();

    // Convert to JDK8 types
    Instant now = MoreTimestamps.toInstantUtc(timeReply.getTime());
    System.out.println("The time is " + now);
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Test
public void getAllAuthoritiesRejected() throws Exception {
    Authentication authentication = new UsernamePasswordAuthenticationToken(
        DEFAULT_EMAIL,
        DEFAULT_PASSWORD,
        Collections.singletonList(new SimpleGrantedAuthority(AuthoritiesConstants.USER))
    );
    SecurityContextHolder.getContext().setAuthentication(authentication);

    try {
        List<String> roles = new ArrayList<>();
        stub.getAllAuthorities(Empty.getDefaultInstance()).forEachRemaining(role -> roles.add(role.getValue()));
        failBecauseExceptionWasNotThrown(StatusRuntimeException.class);
    } catch (StatusRuntimeException e){
        assertThat(e.getStatus().getCode()).isEqualTo(Status.Code.PERMISSION_DENIED);
    }
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Override
public Flux<Metric> getMetrics(Mono<Empty> request) {
    return request
        .flatMapIterable(empty -> publicMetrics)
        .flatMapIterable(PublicMetrics::metrics)
        .map(metric -> {
            Metric.Builder builder = Metric.newBuilder()
                .setName(metric.getName());
            if (metric.getTimestamp() != null) {
                builder.setTimestamp(ProtobufMappers.dateToTimestamp(metric.getTimestamp()));
            }
            if (metric.getValue() instanceof Long || metric.getValue() instanceof Integer) {
                builder.setLongValue(metric.getValue().longValue());
            } else if (metric.getValue() instanceof Float || metric.getValue() instanceof Double) {
                builder.setDoubleValue((metric.getValue()).doubleValue());
            } else {
                builder.setStringValue(metric.getValue().toString());
            }
            return builder.build();
        });
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
/**
 * Tests that when ackMessages() succeeds and the subsequent call to poll() has no messages, that
 * the subscriber does not invoke ackMessages because there should be no acks.
 */
@Test
public void testPollInRegularCase() throws Exception {
  task.start(props);
  ReceivedMessage rm1 = createReceivedMessage(ACK_ID1, CPS_MESSAGE, new HashMap<String, String>());
  PullResponse stubbedPullResponse = PullResponse.newBuilder().addReceivedMessages(rm1).build();
  when(subscriber.pull(any(PullRequest.class)).get()).thenReturn(stubbedPullResponse);
  List<SourceRecord> result = task.poll();
  assertEquals(1, result.size());
  stubbedPullResponse = PullResponse.newBuilder().build();
  ListenableFuture<Empty> goodFuture = Futures.immediateFuture(Empty.getDefaultInstance());
  when(subscriber.ackMessages(any(AcknowledgeRequest.class))).thenReturn(goodFuture);
  when(subscriber.pull(any(PullRequest.class)).get()).thenReturn(stubbedPullResponse);
  result = task.poll();
  assertEquals(0, result.size());
  result = task.poll();
  assertEquals(0, result.size());
  verify(subscriber, times(1)).ackMessages(any(AcknowledgeRequest.class));
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
private void rescheduleForTenant(final TenantId tenantId) {
    final TenantAwareFunction0<Iterator<Command>> func =
            new TenantAwareFunction0<Iterator<Command>>(tenantId) {
                @Override
                public Iterator<Command> apply() {
                    return commandStore().iterator(SCHEDULED);
                }
            };

    final Iterator<Command> commands = func.execute(Empty.getDefaultInstance());

    final TenantAwareOperation op = new TenantAwareOperation(tenantId) {
        @Override
        public void run() {
            while (commands.hasNext()) {
                final Command command = commands.next();
                reschedule(command);
            }
        }
    };
    op.execute();
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Test
public void callCompletionStatusesAreRecorded() throws InterruptedException {
  CallCompletionStatusInterceptor interceptor = new CallCompletionStatusInterceptor();

  when(channelStub.newCall(BigtableServiceGrpc.CONFIG.mutateRow)).thenReturn(callStub);

  CompletionStatusGatheringCall<MutateRowRequest, Empty> wrappedCall =
      interceptor.interceptCall(BigtableServiceGrpc.CONFIG.mutateRow, channelStub);

  Listener<Empty> statusGatheringListener =
      wrappedCall.createGatheringListener(responseListenerStub);

  statusGatheringListener.onClose(Status.INTERNAL, new Metadata.Trailers());

  CallCompletionStatusInterceptor.CallCompletionStatus expectedStatusEntry =
      new CallCompletionStatusInterceptor.CallCompletionStatus(
          BigtableServiceGrpc.CONFIG.mutateRow, Status.INTERNAL);

  Assert.assertEquals(1, interceptor.getCallCompletionStatuses().count(expectedStatusEntry));
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Test
public void successfulCallsAreNotRetried() {
  RetryListener<MutateRowRequest, Empty> listener =
      new RetryListener<>(
          mockRetryingCall,
          request,
          new Headers.Headers(),
          true, // always retriable for testing
          mockResponseListener);

  listener.onHeaders(new Headers.Headers());
  listener.onPayload(response);
  listener.onClose(Status.OK, new Trailers.Trailers());

  // Validate that the listener did not attempt to start a new call on the channel:
  verifyNoMoreInteractions(mockRetryingCall);

  // Verify that the mockResponseListener was informed of the payload and closed:
  verify(mockResponseListener, times(1)).onPayload(eq(response));
  verify(mockResponseListener, times(1)).onClose(eq(Status.OK), any(Trailers.Trailers.class));
}
 

import com.google.protobuf.Empty; //导入依赖的package包/类
@Test
public void failuresAfterHeadersAreReceivedIsNotRetried() {
  Headers requestHeaders = new Headers.Headers();
  RetryListener<MutateRowRequest, Empty> listener =
      new RetryListener<>(
          mockRetryingCall,
          request,
          requestHeaders,
          true, // always retriable for testing
          mockResponseListener);

  Headers responseHeaders = new Headers.Headers();
  listener.onHeaders(responseHeaders);
  listener.onPayload(response);
  listener.onClose(Status.INTERNAL, new Trailers.Trailers());

  // Validate that the listener did not attempt to start a new call on the channel:
  verifyNoMoreInteractions(mockRetryingCall);

  // Verify that the mockResponseListener was informed of the payload and closed:
  verify(mockResponseListener, times(1)).onHeaders(eq(responseHeaders));
  verify(mockResponseListener, times(1)).onPayload(eq(response));
  verify(mockResponseListener, times(1)).onClose(
      eq(Status.INTERNAL), any(Trailers.Trailers.class));
}