@Override public void onCompleted() { if (cancelled) { throw Status.CANCELLED.asRuntimeException(); } else { call.close(Status.OK, new Metadata()); } }
@Override public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) { System.out.println(call.getMethodDescriptor().getFullMethodName()); log.info(call.getMethodDescriptor().getFullMethodName()); return next.startCall(call, headers); } }
/** * Partition the limit by a request attribute. * @return Chainable builder */ public GrpcServerLimiterBuilder partitionByAttribute(Attributes.Key<String> attribute) { return partitionResolver(context -> context.getCall().getAttributes().get(attribute)); }
private <ReqT, RespT> boolean authenticateCall(ServerCall<ReqT, RespT> call, Metadata headers) { // Try to fetch channel Id from the metadata. UUID channelId = headers.get(ChannelIdInjector.S_CLIENT_ID_KEY); boolean callAuthenticated = false; if (channelId != null) { try { // Fetch authenticated username for this channel and set it. String userName = mAuthenticationServer.getUserNameForChannel(channelId); if (userName != null) { AuthenticatedClientUser.set(userName); } else { AuthenticatedClientUser.remove(); } callAuthenticated = true; } catch (UnauthenticatedException e) { LOG.debug("Channel:{} is not authenticated for call:{}", channelId.toString(), call.getMethodDescriptor().getFullMethodName()); call.close(Status.UNAUTHENTICATED, headers); } } else { LOG.debug("Channel Id is missing for call:{}.", call.getMethodDescriptor().getFullMethodName()); call.close(Status.UNAUTHENTICATED, headers); } return callAuthenticated; } }
final String operationName = operationNameConstructor.constructOperationName(call.getMethodDescriptor()); final Span span = getSpanFromHeaders(headerMap, operationName); switch (attr) { case METHOD_TYPE: span.setTag("grpc.method_type", call.getMethodDescriptor().getType().toString()); break; case METHOD_NAME: span.setTag("grpc.method_name", call.getMethodDescriptor().getFullMethodName()); break; case CALL_ATTRIBUTES: span.setTag("grpc.call_attributes", call.getAttributes().toString()); break; case HEADERS:
@Override public ServerCall.Listener<ReqT> startCall(ServerCall<ReqT, RespT> call, Metadata headers) { Preconditions.checkArgument( call.getMethodDescriptor().getType().clientSendsOneMessage(), "asyncUnaryRequestCall is only for clientSendsOneMessage methods"); ServerCallStreamObserverImpl<ReqT, RespT> responseObserver = new ServerCallStreamObserverImpl<ReqT, RespT>(call); // We expect only 1 request, but we ask for 2 requests here so that if a misbehaving client // sends more than 1 requests, ServerCall will catch it. Note that disabling auto // inbound flow control has no effect on unary calls. call.request(2); return new UnaryServerCallListener(responseObserver, call); }
@Override public void request(int count) { call.request(count); } }
@Override public void setCompression(String compression) { call.setCompression(compression); }
@Override public boolean isCancelled() { return call.isCancelled(); }
@Override public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> serverCall, Metadata metadata, ServerCallHandler<ReqT, RespT> serverCallHandler) { String resourceName = serverCall.getMethodDescriptor().getFullMethodName(); serverCall.close(FLOW_CONTROL_BLOCK, new Metadata()); return new ServerCall.Listener<ReqT>() {}; } finally {
@Override public Listener<ReqT> startCall(ServerCall<ReqT, RespT> serverCall, Metadata headers) { Channel channel = finder.findChannel(serverCall, headers); ClientCall<ReqT, RespT> clientCall = channel.newCall( serverCall.getMethodDescriptor(), callOptions); ProxyCall<ReqT, RespT> proxyCall = new ProxyCall<>( serverCall, clientCall); clientCall.start(proxyCall.getClientCallListener(), headers); serverCall.request(1); clientCall.request(1); return proxyCall.getServerCallListener(); } }
private <ReqT, RespT> Listener<ReqT> unaryCall(final ServerCall<ReqT, RespT> call, final Metadata headers) { final ServerCallStreamObserverImpl<ReqT, RespT> responseObserver = new ServerCallStreamObserverImpl<ReqT, RespT>(call); call.request(2); return new ServerCall.Listener<ReqT>() { ReqT request;
@SuppressWarnings({"unchecked", "rawtypes"}) @Override public Listener startCall(ServerCall call, Metadata headers) { if (!inited) { throw new MotanFrameworkException("grpc ServerCallHandler not inited!"); } // TODO check header if (provider.getUrl().getBooleanParameter(URLParamType.usegz.getName(), URLParamType.usegz.getBooleanValue())){ call.setCompression("gzip"); } return requestStream ? streamCall(call, headers) : unaryCall(call, headers); }
@Override public boolean isCancelled() { return call.isCancelled(); }
@Override public void onError(Throwable t) { Metadata metadata = Status.trailersFromThrowable(t); if (metadata == null) { metadata = new Metadata(); } if (t instanceof MotanBizException) { call.close(Status.INTERNAL.withDescription(t.getMessage()).withCause(t), metadata); } else { call.close(Status.UNAVAILABLE.withDescription(t.getMessage()).withCause(t), metadata); } }
/** Override the customize the span based on the start of a request. */ protected <ReqT, RespT> void onStart(ServerCall<ReqT, RespT> call, Metadata headers, SpanCustomizer span) { span.name(spanName(call.getMethodDescriptor())); } }
@Override public Authentication readAuthentication(final ServerCall<?, ?> call, final Metadata metadata) { final SSLSession sslSession = call.getAttributes().get(Grpc.TRANSPORT_ATTR_SSL_SESSION); if (sslSession == null) { log.trace("Peer not verified via SSL"); return null; } Certificate[] certs; try { certs = sslSession.getPeerCertificates(); } catch (final SSLPeerUnverifiedException e) { log.trace("Peer not verified via certificate", e); return null; } return fromCertificate(certs[certs.length - 1]); }
responseObserver.freeze(); if (responseObserver.autoFlowControlEnabled) { call.request(1);
@Override public void setCompression(String compression) { call.setCompression(compression); }
@Override public boolean isCancelled() { return delegate().isCancelled(); }