use of io.grpc.ClientInterceptor in project toolkit by googleapis.
the class Pubsub method gapic.
private static void gapic(final Settings settings) throws Exception {
ScheduledThreadPoolExecutor executor = new ScheduledThreadPoolExecutor(1);
// In real clients, InstantiatingChannelProvider is responsible for adding interceptors.
// We can't use it here because InstantiatingChannelProvider doesn't have sslContext method.
// Instead, we imitate HeaderInterceptor.
ClientInterceptor headerInterceptor = new ClientInterceptor() {
@Override
public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
ClientCall<ReqT, RespT> call = next.newCall(method, callOptions);
return new SimpleForwardingClientCall<ReqT, RespT>(call) {
@Override
public void start(ClientCall.Listener<RespT> responseListener, Metadata headers) {
headers.put(X_GOOG_HEADER_KEY, X_GOOG_HEADER_VALUE);
super.start(responseListener, headers);
}
};
}
};
ManagedChannel channel = NettyChannelBuilder.forTarget(settings.endpoint()).executor(executor).sslContext(GrpcSslContexts.forClient().trustManager(new File(settings.cert())).build()).intercept(headerInterceptor).build();
final Semaphore semaphore = new Semaphore(settings.numWorkers());
final TopicAdminClient client = TopicAdminClient.create(TopicAdminSettings.defaultBuilder().setChannelProvider(FixedChannelProvider.create(channel)).setExecutorProvider(FixedExecutorProvider.create(executor)).build());
final AtomicLong resetTime = new AtomicLong();
final AtomicLong numCalls = new AtomicLong();
final AtomicLong numErrs = new AtomicLong();
long endTime = System.nanoTime() + settings.warmDurNano() + settings.targetDurNano();
Thread resetter = new Thread(() -> {
try {
Thread.sleep(settings.warmDurNano() / MILLION);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
numCalls.set(0);
numErrs.set(0);
resetTime.set(System.nanoTime());
});
resetter.start();
while (System.nanoTime() < endTime) {
semaphore.acquire(1);
ApiFutures.addCallback(client.getTopicCallable().futureCall(GetTopicRequest.newBuilder().setTopicWithTopicName(TOPIC_NAME_RESOURCE).build()), new ApiFutureCallback<Topic>() {
@Override
public void onSuccess(Topic topic) {
if (!topic.getName().equals(TOPIC_NAME_STRING)) {
numErrs.incrementAndGet();
}
both();
}
@Override
public void onFailure(Throwable t) {
numErrs.incrementAndGet();
both();
}
void both() {
numCalls.incrementAndGet();
semaphore.release(1);
}
});
}
long nCalls = numCalls.get();
long nErrs = numErrs.get();
long runDurNano = System.nanoTime() - resetTime.get();
System.out.println("errors: " + nErrs);
System.out.println("calls: " + nCalls);
System.out.println("time per call (ns): " + (runDurNano / nCalls));
System.out.println("QPS: " + (nCalls * BILLION / runDurNano));
client.close();
channel.shutdown().awaitTermination(10, TimeUnit.SECONDS);
executor.shutdown();
executor.awaitTermination(10, TimeUnit.SECONDS);
}
use of io.grpc.ClientInterceptor in project brave by openzipkin.
the class BaseITTracingClientInterceptor method initMessageTaggingClient.
void initMessageTaggingClient() {
SpanCustomizer customizer = CurrentSpanCustomizer.create(tracing);
AtomicInteger sends = new AtomicInteger(1);
AtomicInteger recvs = new AtomicInteger(1);
closeClient(client);
client = newClient(new ClientInterceptor() {
@Override
public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {
return new SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {
@Override
public void start(Listener<RespT> responseListener, Metadata headers) {
super.start(new SimpleForwardingClientCallListener<RespT>(responseListener) {
@Override
public void onMessage(RespT message) {
customizer.tag("grpc.message_recv." + recvs.getAndIncrement(), message.toString());
delegate().onMessage(message);
}
}, headers);
}
@Override
public void sendMessage(ReqT message) {
customizer.tag("grpc.message_send." + sends.getAndIncrement(), message.toString());
delegate().sendMessage(message);
}
};
}
}, grpcTracing.newClientInterceptor());
}
use of io.grpc.ClientInterceptor in project pravega by pravega.
the class RPCTracingHelpersTest method testInterceptors.
@Test
@SuppressWarnings({ "unchecked", "rawtypes" })
public void testInterceptors() {
String requestDescriptor = "createStream-myScope-myStream";
long requestId = 1234L;
ClientInterceptor clientInterceptor = RPCTracingHelpers.getClientInterceptor();
RequestTracker requestTracker = new RequestTracker(true);
// Mocking RPC elements.
MethodDescriptor.Marshaller<Object> mockMarshaller = Mockito.mock(MethodDescriptor.Marshaller.class);
ClientCall.Listener<Object> listener = Mockito.mock(ClientCall.Listener.class);
ServerCall serverCall = Mockito.mock(ServerCall.class);
ServerCallHandler serverCallHandler = Mockito.mock(ServerCallHandler.class);
@Cleanup("shutdown") ManagedChannel channel = NettyChannelBuilder.forTarget("localhost").build();
MethodDescriptor method = MethodDescriptor.newBuilder().setFullMethodName("createStream").setType(MethodDescriptor.MethodType.UNARY).setRequestMarshaller(mockMarshaller).setResponseMarshaller(mockMarshaller).build();
Mockito.when(serverCall.getMethodDescriptor()).thenReturn(method);
// Actual elements to work with.
CallOptions callOptions = CallOptions.DEFAULT;
Metadata headers = new Metadata();
// Test that headers do not contain tracing-related key/values, as call options are not set.
clientInterceptor.interceptCall(method, callOptions, channel).start(listener, headers);
assertFalse(headers.containsKey(RPCTracingHelpers.DESCRIPTOR_HEADER));
assertFalse(headers.containsKey(RPCTracingHelpers.ID_HEADER));
// Check that the server interceptor handles clients not sending tracing headers and that the cache remains clean.
ServerInterceptor serverInterceptor = RPCTracingHelpers.getServerInterceptor(requestTracker);
serverInterceptor.interceptCall(serverCall, headers, serverCallHandler);
assertEquals(0, requestTracker.getNumDescriptors());
// Add call options and check that headers are correctly set.
callOptions = callOptions.withOption(RPCTracingHelpers.REQUEST_DESCRIPTOR_CALL_OPTION, requestDescriptor).withOption(RPCTracingHelpers.REQUEST_ID_CALL_OPTION, String.valueOf(requestId));
clientInterceptor.interceptCall(method, callOptions, channel).start(listener, headers);
assertEquals(requestDescriptor, headers.get(RPCTracingHelpers.DESCRIPTOR_HEADER));
assertEquals(requestId, Long.parseLong(headers.get(RPCTracingHelpers.ID_HEADER)));
// Test that the server interceptor correctly sets these headers in the cache for further tracking.
serverInterceptor.interceptCall(serverCall, headers, serverCallHandler);
assertEquals(1, requestTracker.getNumDescriptors());
assertEquals(requestId, requestTracker.getRequestIdFor(requestDescriptor));
}
use of io.grpc.ClientInterceptor in project pinpoint by naver.
the class SpanGrpcDataSenderProvider method newChannelFactoryBuilder.
private ChannelFactoryBuilder newChannelFactoryBuilder(boolean sslEnable) {
final int channelExecutorQueueSize = grpcTransportConfig.getSpanChannelExecutorQueueSize();
final ClientOption clientOption = grpcTransportConfig.getSpanClientOption();
ChannelFactoryBuilder channelFactoryBuilder = new DefaultChannelFactoryBuilder("SpanGrpcDataSender");
channelFactoryBuilder.setHeaderFactory(headerFactory);
channelFactoryBuilder.setNameResolverProvider(nameResolverProvider);
final ClientInterceptor unaryCallDeadlineInterceptor = new UnaryCallDeadlineInterceptor(grpcTransportConfig.getSpanRequestTimeout());
channelFactoryBuilder.addClientInterceptor(unaryCallDeadlineInterceptor);
// channelFactoryBuilder.addClientInterceptor(discardClientInterceptor);
if (clientInterceptorList != null) {
for (ClientInterceptor clientInterceptor : clientInterceptorList) {
logger.info("addClientInterceptor:{}", clientInterceptor);
channelFactoryBuilder.addClientInterceptor(clientInterceptor);
}
}
channelFactoryBuilder.setExecutorQueueSize(channelExecutorQueueSize);
channelFactoryBuilder.setClientOption(clientOption);
if (sslEnable) {
SslOption sslOption = grpcTransportConfig.getSslOption();
channelFactoryBuilder.setSslOption(sslOption);
}
return channelFactoryBuilder;
}
use of io.grpc.ClientInterceptor in project pinpoint by naver.
the class DefaultChannelFactory method addHeader.
private void addHeader(NettyChannelBuilder channelBuilder) {
final Metadata extraHeaders = headerFactory.newHeader();
if (logger.isDebugEnabled()) {
logger.debug("addHeader {}", extraHeaders);
}
final ClientInterceptor headersInterceptor = MetadataUtils.newAttachHeadersInterceptor(extraHeaders);
channelBuilder.intercept(headersInterceptor);
}
Aggregations