Uses of Class
io.grpc.Metadata

Packages that use Metadata

Package	Description
io.grpc	The gRPC core public API.
io.grpc.grpclb
io.grpc.inprocess	The in-process transport which is for when a server is in the same process as the client.
io.grpc.internal	Interfaces and implementations that are internal to gRPC.
io.grpc.netty	The main transport implementation based on Netty, for both the client and the server.
io.grpc.protobuf	API for gRPC over Protocol Buffers, including tools for serializing and de-serializing protobuf messages.
io.grpc.protobuf.services	Service definitions and utilities with protobuf dependency for the pre-defined gRPC services.
io.grpc.rls
io.grpc.servlet	API that implements gRPC server as a servlet.
io.grpc.servlet.jakarta	API that implements gRPC server as a servlet.
io.grpc.stub	API for the Stub layer.
io.grpc.util	Utilities with advanced features in the core layer that user can optionally use.

Uses of Metadata in io.grpc

Fields in io.grpc declared as Metadata

Modifier and Type	Field	Description
private final Metadata	CompositeCallCredentials.CombiningMetadataApplier.firstHeaders
private final Metadata	StatusException.trailers
private final Metadata	StatusRuntimeException.trailers

Methods in io.grpc that return Metadata

Modifier and Type	Method	Description
abstract Metadata	LoadBalancer.PickSubchannelArgs.getHeaders()	Headers of the call.
final Metadata	StatusException.getTrailers()	Returns the received trailers.
final Metadata	StatusRuntimeException.getTrailers()	Returns the received trailers.
static Metadata	InternalMetadata.newMetadata(byte[]... binaryValues)
static Metadata	InternalMetadata.newMetadata(int usedNames, byte[]... binaryValues)
static Metadata	InternalMetadata.newMetadataWithParsedValues(int usedNames, Object[] namesAndValues)	Creates a new Metadata instance from serialized data, with some values pre-parsed.
static Metadata	Status.trailersFromThrowable(Throwable t)	Extract an error trailers from the causal chain of a Throwable.

Methods in io.grpc with parameters of type Metadata

Modifier and Type	Method	Description
abstract void	CallCredentials.MetadataApplier.apply(Metadata headers)	Called when headers are successfully generated.
void	CompositeCallCredentials.CombiningMetadataApplier.apply(Metadata headers)
void	CompositeCallCredentials.WrappingMetadataApplier.apply(Metadata headers)
StatusException	Status.asException(Metadata trailers)	Same as Status.asException() but includes the provided trailers in the returned exception.
static final StatusRuntimeException	InternalStatus.asRuntimeException(Status status, Metadata trailers, boolean fillInStackTrace)	Create a new StatusRuntimeException with the internal option of skipping the filling of the stack trace.
StatusRuntimeException	Status.asRuntimeException(Metadata trailers)	Same as Status.asRuntimeException() but includes the provided trailers in the returned exception.
protected abstract void	ClientInterceptors.CheckedForwardingClientCall.checkedStart(ClientCall.Listener<RespT> responseListener, Metadata headers)	Subclasses implement the start logic here that would normally belong to start().
void	PartialForwardingServerCall.close(Status status, Metadata trailers)
abstract void	ServerCall.close(Status status, Metadata trailers)	Close the call with the provided status.
<ReqT, RespT> Executor	ServerCallExecutorSupplier.getExecutor(ServerCall<ReqT,RespT> call, Metadata metadata)	Returns an executor to handle the server call.
static int	InternalMetadata.headerCount(Metadata md)
void	ClientStreamTracer.inboundHeaders(Metadata headers)	Headers has been received from the server.
void	ClientStreamTracer.inboundTrailers(Metadata trailers)	Trailing metadata has been received from the server.
static <ReqT, RespT> ServerCall.Listener<ReqT>	Contexts.interceptCall(Context context, ServerCall<ReqT,RespT> call, Metadata headers, ServerCallHandler<ReqT,RespT> next)	Make the provided Context Context.current() for the creation of a listener to a received call and for all events received by that listener.
<ReqT, RespT> ServerCall.Listener<ReqT>	ServerInterceptor.interceptCall(ServerCall<ReqT,RespT> call, Metadata headers, ServerCallHandler<ReqT,RespT> next)	Intercept ServerCall dispatch by the next ServerCallHandler.
void	Metadata.merge(Metadata other)	Perform a simple merge of two sets of metadata.
void	Metadata.merge(Metadata other, Set<Metadata.Key<?>> keys)	Merge values from the given set of keys into this set of metadata.
ClientStreamTracer	ClientStreamTracer.Factory.newClientStreamTracer(ClientStreamTracer.StreamInfo info, Metadata headers)	Creates a ClientStreamTracer for a new client stream.
abstract ServerStreamTracer	ServerStreamTracer.Factory.newServerStreamTracer(String fullMethodName, Metadata headers)	Creates a ServerStreamTracer for a new server stream.
void	ClientCall.Listener.onClose(Status status, Metadata trailers)	The ClientCall has been closed.
void	PartialForwardingClientCallListener.onClose(Status status, Metadata trailers)
void	ClientCall.Listener.onHeaders(Metadata headers)	The response headers have been received.
void	PartialForwardingClientCallListener.onHeaders(Metadata headers)
void	PartialForwardingServerCall.sendHeaders(Metadata headers)
abstract void	ServerCall.sendHeaders(Metadata headers)	Send response header metadata prior to sending a response message.
static byte[][]	InternalMetadata.serialize(Metadata md)
static Object[]	InternalMetadata.serializePartial(Metadata md)	Serializes all metadata entries, leaving some values as InputStreams.
abstract void	ClientCall.start(ClientCall.Listener<RespT> responseListener, Metadata headers)	Start a call, using responseListener for processing response messages.
final void	ClientInterceptors.CheckedForwardingClientCall.start(ClientCall.Listener<RespT> responseListener, Metadata headers)
void	ForwardingClientCall.start(ClientCall.Listener<RespT> responseListener, Metadata headers)
ServerCall.Listener<RequestT>	ServerCallHandler.startCall(ServerCall<RequestT,ResponseT> call, Metadata headers)	Starts asynchronous processing of an incoming call.
ServerCall.Listener<ReqT>	ServerInterceptors.InterceptCallHandler.startCall(ServerCall<ReqT,RespT> call, Metadata headers)
void	ClientStreamTracer.streamCreated(Attributes transportAttrs, Metadata headers)	The stream is being created on a ready transport.

Constructors in io.grpc with parameters of type Metadata

Modifier	Constructor	Description
	CombiningMetadataApplier(CallCredentials.MetadataApplier delegate, Metadata firstHeaders)
	StatusException(Status status, Metadata trailers)	Constructs an exception with both a status and trailers.
(package private)	StatusException(Status status, Metadata trailers, boolean fillInStackTrace)
	StatusRuntimeException(Status status, Metadata trailers)	Constructs the exception with both a status and trailers.
(package private)	StatusRuntimeException(Status status, Metadata trailers, boolean fillInStackTrace)

Uses of Metadata in io.grpc.grpclb

Methods in io.grpc.grpclb with parameters of type Metadata

Modifier and Type	Method	Description
ClientStreamTracer	GrpclbClientLoadRecorder.newClientStreamTracer(ClientStreamTracer.StreamInfo info, Metadata headers)
ClientStreamTracer	TokenAttachingTracerFactory.newClientStreamTracer(ClientStreamTracer.StreamInfo info, Metadata headers)
LoadBalancer.PickResult	GrpclbState.BackendEntry.picked(Metadata headers)
LoadBalancer.PickResult	GrpclbState.ErrorEntry.picked(Metadata headers)
LoadBalancer.PickResult	GrpclbState.IdleSubchannelEntry.picked(Metadata headers)
LoadBalancer.PickResult	GrpclbState.RoundRobinEntry.picked(Metadata headers)

Uses of Metadata in io.grpc.inprocess

Fields in io.grpc.inprocess declared as Metadata

Modifier and Type	Field	Description
private Metadata	InProcessTransport.InProcessStream.InProcessServerStream.clientNotifyTrailers
private final Metadata	InProcessTransport.InProcessStream.headers

Methods in io.grpc.inprocess with parameters of type Metadata

Modifier and Type	Method	Description
void	InProcessTransport.InProcessStream.InProcessServerStream.close(Status status, Metadata trailers)
private static int	InProcessTransport.metadataSize(Metadata metadata)
ClientStream	InProcessTransport.newStream(MethodDescriptor<?,?> method, Metadata headers, CallOptions callOptions, ClientStreamTracer[] tracers)
private void	InProcessTransport.InProcessStream.InProcessServerStream.notifyClientClose(Status status, Metadata trailers)	clientStream.serverClosed() must be called before this method
void	InProcessTransport.InProcessStream.InProcessServerStream.writeHeaders(Metadata headers, boolean flush)

Constructors in io.grpc.inprocess with parameters of type Metadata

Modifier	Constructor	Description
(package private)	InProcessServerStream(MethodDescriptor<?,?> method, Metadata headers)
private	InProcessStream(MethodDescriptor<?,?> method, Metadata headers, CallOptions callOptions, String authority, StatsTraceContext statsTraceContext)

Uses of Metadata in io.grpc.internal

Fields in io.grpc.internal declared as Metadata

Modifier and Type	Field	Description
private Metadata	AbstractClientStream.GetFramer.headers
private Metadata	AbstractClientStream.headers
private final Metadata	PickSubchannelArgsImpl.headers
private final Metadata	RetriableStream.headers
private final Metadata	RetriableStream.SavedCloseMasterListenerReason.metadata
private final Metadata	MetadataApplierImpl.origHeaders
private Metadata	Http2ClientStreamTransportState.transportErrorMetadata

Methods in io.grpc.internal that return Metadata

Modifier and Type	Method	Description
Metadata	PickSubchannelArgsImpl.getHeaders()
(package private) final Metadata	RetriableStream.updateHeaders(Metadata originalHeaders, int previousAttemptCount)	Adds grpc-previous-rpc-attempts in the headers of a retry/hedging RPC.

Methods in io.grpc.internal with parameters of type Metadata

Modifier and Type	Method	Description
private void	AbstractServerStream.addStatusToTrailers(Metadata trailers, Status status)
void	MetadataApplierImpl.apply(Metadata headers)
void	StatsTraceContext.clientInboundHeaders(Metadata headers)	See ClientStreamTracer.inboundHeaders().
void	StatsTraceContext.clientInboundTrailers(Metadata trailers)	See ClientStreamTracer.inboundTrailers(io.grpc.Metadata).
final void	AbstractServerStream.close(Status status, Metadata trailers)
void	ServerCallImpl.close(Status status, Metadata trailers)
void	ServerStream.close(Status status, Metadata trailers)	Closes the stream for both reading and writing.
void	ClientCallImpl.ClientStreamListenerImpl.closed(Status status, ClientStreamListener.RpcProgress rpcProgress, Metadata trailers)
void	ClientStreamListener.closed(Status status, ClientStreamListener.RpcProgress rpcProgress, Metadata trailers)	Called when the stream is fully closed.
void	DelayedStream.DelayedStreamListener.closed(Status status, ClientStreamListener.RpcProgress rpcProgress, Metadata trailers)
void	ForwardingClientStreamListener.closed(Status status, ClientStreamListener.RpcProgress rpcProgress, Metadata trailers)
void	RetriableStream.Sublistener.closed(Status status, ClientStreamListener.RpcProgress rpcProgress, Metadata trailers)
private void	ClientCallImpl.ClientStreamListenerImpl.closedInternal(Status status, ClientStreamListener.RpcProgress rpcProgress, Metadata trailers)
private void	ServerCallImpl.closeInternal(Status status, Metadata trailers)
private void	AbstractClientStream.TransportState.closeListener(Status status, ClientStreamListener.RpcProgress rpcProgress, Metadata trailers)	Closes the listener if not previously closed.
private void	ClientCallImpl.closeObserver(ClientCall.Listener<RespT> observer, Status status, Metadata trailers)
private Context.CancellableContext	ServerImpl.ServerTransportListenerImpl.createContext(Metadata headers, StatsTraceContext statsTraceCtx)
private static Charset	Http2ClientStreamTransportState.extractCharset(Metadata headers)	Inspect the raw metadata and figure out what charset is being used.
static ClientStreamTracer[]	GrpcUtil.getClientStreamTracers(CallOptions callOptions, Metadata headers, int previousAttempts, boolean isTransparentRetry)	Gets stream tracers based on CallOptions.
private Integer	RetriableStream.Sublistener.getPushbackMills(Metadata trailer)
void	ClientCallImpl.ClientStreamListenerImpl.headersRead(Metadata headers)
void	ClientStreamListener.headersRead(Metadata headers)	Called upon receiving all header information from the remote end-point.
void	DelayedStream.DelayedStreamListener.headersRead(Metadata headers)
void	ForwardingClientStreamListener.headersRead(Metadata headers)
void	RetriableStream.Sublistener.headersRead(Metadata headers)
protected abstract void	Http2ClientStreamTransportState.http2ProcessingFailed(Status status, boolean stopDelivery, Metadata trailers)	Called to process a failure in HTTP/2 processing.
void	ForwardingClientStreamTracer.inboundHeaders(Metadata headers)
protected void	AbstractClientStream.TransportState.inboundHeadersReceived(Metadata headers)	Called by transport implementations when they receive headers.
void	ForwardingClientStreamTracer.inboundTrailers(Metadata trailers)
protected void	AbstractClientStream.TransportState.inboundTrailersReceived(Metadata trailers, Status status)	Processes the trailers and status from the server.
private RetriableStream.HedgingPlan	RetriableStream.Sublistener.makeHedgingDecision(Status status, Metadata trailer)
private RetriableStream.RetryPlan	RetriableStream.Sublistener.makeRetryDecision(Status status, Metadata trailer)	Decides in current situation whether or not the RPC should retry and if it should retry how long the backoff should be.
static StatsTraceContext	StatsTraceContext.newClientContext(ClientStreamTracer[] tracers, Attributes transportAtts, Metadata headers)	Factory method for the client-side.
static StatsTraceContext	StatsTraceContext.newServerContext(List<? extends ServerStreamTracer.Factory> factories, String fullMethodName, Metadata headers)	Factory method for the server-side.
ClientStream	CallCredentialsApplyingTransportFactory.CallCredentialsApplyingTransport.newStream(MethodDescriptor<?,?> method, Metadata headers, CallOptions callOptions, ClientStreamTracer[] tracers)
ClientStream	ClientCallImpl.ClientStreamProvider.newStream(MethodDescriptor<?,?> method, CallOptions callOptions, Metadata headers, Context context)
ClientStream	ClientTransport.newStream(MethodDescriptor<?,?> method, Metadata headers, CallOptions callOptions, ClientStreamTracer[] tracers)	Creates a new stream for sending messages to a remote end-point.
final ClientStream	DelayedClientTransport.newStream(MethodDescriptor<?,?> method, Metadata headers, CallOptions callOptions, ClientStreamTracer[] tracers)	If a LoadBalancer.SubchannelPicker is being, or has been provided via DelayedClientTransport.reprocess(io.grpc.LoadBalancer.SubchannelPicker), the last picker will be consulted.
ClientStream	FailingClientTransport.newStream(MethodDescriptor<?,?> method, Metadata headers, CallOptions callOptions, ClientStreamTracer[] tracers)
ClientStream	ForwardingConnectionClientTransport.newStream(MethodDescriptor<?,?> method, Metadata headers, CallOptions callOptions, ClientStreamTracer[] tracers)
ClientStream	InternalSubchannel.CallTracingTransport.newStream(MethodDescriptor<?,?> method, Metadata headers, CallOptions callOptions, ClientStreamTracer[] tracers)
ClientStream	ManagedChannelImpl.ChannelStreamProvider.newStream(MethodDescriptor<?,?> method, CallOptions callOptions, Metadata headers, Context context)
(package private) abstract ClientStream	RetriableStream.newSubstream(Metadata headers, ClientStreamTracer.Factory tracerFactory, int previousAttempts, boolean isTransparentRetry)	Creates a new physical ClientStream that represents a retry/hedging attempt.
void	DelayedClientCall.DelayedListener.onClose(Status status, Metadata trailers)
void	DelayedClientCall.DelayedListener.onHeaders(Metadata headers)
(package private) static void	ClientCallImpl.prepareHeaders(Metadata headers, DecompressorRegistry decompressorRegistry, Compressor compressor, boolean fullStreamDecompression)
private void	RetriableStream.safeCloseMasterListener(Status status, ClientStreamListener.RpcProgress progress, Metadata metadata)
void	ServerCallImpl.sendHeaders(Metadata headers)
private void	ServerCallImpl.sendHeadersInternal(Metadata headers)
void	ClientCallImpl.start(ClientCall.Listener<RespT> observer, Metadata headers)
final void	DelayedClientCall.start(ClientCall.Listener<RespT> listener, Metadata headers)
void	ManagedChannelImpl.ConfigSelectingClientCall.start(ClientCall.Listener<RespT> observer, Metadata headers)
private void	ClientCallImpl.startInternal(ClientCall.Listener<RespT> observer, Metadata headers)
private <WReqT, WRespT> ServerStreamListener	ServerImpl.ServerTransportListenerImpl.startWrappedCall(String fullMethodName, ServerImpl.ServerTransportListenerImpl.ServerCallParameters<WReqT,WRespT> params, Metadata headers)
private Status	Http2ClientStreamTransportState.statusFromTrailers(Metadata trailers)	Extract the response status from trailers.
void	ForwardingClientStreamTracer.streamCreated(Attributes transportAttrs, Metadata headers)
void	ServerImpl.ServerTransportListenerImpl.streamCreated(ServerStream stream, String methodName, Metadata headers)
void	ServerTransportListener.streamCreated(ServerStream stream, String method, Metadata headers)	Called when a new stream was created by the remote client.
private void	ServerImpl.ServerTransportListenerImpl.streamCreatedInternal(ServerStream stream, String methodName, Metadata headers, io.perfmark.Tag tag)
private static void	Http2ClientStreamTransportState.stripTransportDetails(Metadata metadata)	Strip HTTP transport implementation details so they don't leak via metadata into the application layer.
static byte[][]	TransportFrameUtil.toHttp2Headers(Metadata headers)	Transform the given headers to a format where only spec-compliant ASCII characters are allowed.
protected void	Http2ClientStreamTransportState.transportHeadersReceived(Metadata headers)	Called by subclasses whenever Headers are received from the transport.
final void	AbstractClientStream.TransportState.transportReportStatus(Status status, boolean stopDelivery, Metadata trailers)	Report stream closure with status to the application layer if not already reported.
final void	AbstractClientStream.TransportState.transportReportStatus(Status status, ClientStreamListener.RpcProgress rpcProgress, boolean stopDelivery, Metadata trailers)	Report stream closure with status to the application layer if not already reported.
protected void	Http2ClientStreamTransportState.transportTrailersReceived(Metadata trailers)	Called by subclasses for the terminal trailer metadata on a stream.
(package private) final Metadata	RetriableStream.updateHeaders(Metadata originalHeaders, int previousAttemptCount)	Adds grpc-previous-rpc-attempts in the headers of a retry/hedging RPC.
private Status	Http2ClientStreamTransportState.validateInitialMetadata(Metadata headers)	Inspect initial headers to make sure they conform to HTTP and gRPC, returning a Status on failure.
void	AbstractClientStream.Sink.writeHeaders(Metadata metadata, byte[] payload)	Sends the request headers to the remote end point.
void	AbstractServerStream.Sink.writeHeaders(Metadata headers, boolean flush)	Sends response headers to the remote end point.
final void	AbstractServerStream.writeHeaders(Metadata headers, boolean flush)
void	ServerStream.writeHeaders(Metadata headers, boolean flush)	Writes custom metadata as headers on the response stream sent to the client.
void	AbstractServerStream.Sink.writeTrailers(Metadata trailers, boolean headersSent, Status status)	Sends trailers to the remote end point.

Constructors in io.grpc.internal with parameters of type Metadata

Modifier	Constructor	Description
protected	AbstractClientStream(WritableBufferAllocator bufferAllocator, StatsTraceContext statsTraceCtx, TransportTracer transportTracer, Metadata headers, CallOptions callOptions, boolean useGet)
	GetFramer(Metadata headers, StatsTraceContext statsTraceCtx)
(package private)	MetadataApplierImpl(ClientTransport transport, MethodDescriptor<?,?> method, Metadata origHeaders, CallOptions callOptions, MetadataApplierImpl.MetadataApplierListener listener, ClientStreamTracer[] tracers)
	PickSubchannelArgsImpl(MethodDescriptor<?,?> method, Metadata headers, CallOptions callOptions, LoadBalancer.PickDetailsConsumer pickDetailsConsumer)	Creates call args object for given method with its call options, metadata.
(package private)	RetriableStream(MethodDescriptor<ReqT,?> method, Metadata headers, RetriableStream.ChannelBufferMeter channelBufferUsed, long perRpcBufferLimit, long channelBufferLimit, Executor callExecutor, ScheduledExecutorService scheduledExecutorService, RetryPolicy retryPolicy, HedgingPolicy hedgingPolicy, RetriableStream.Throttle throttle)
(package private)	SavedCloseMasterListenerReason(Status status, ClientStreamListener.RpcProgress progress, Metadata metadata)
(package private)	ServerCallImpl(ServerStream stream, MethodDescriptor<ReqT,RespT> method, Metadata inboundHeaders, Context.CancellableContext context, DecompressorRegistry decompressorRegistry, CompressorRegistry compressorRegistry, CallTracer serverCallTracer, io.perfmark.Tag tag)

Uses of Metadata in io.grpc.netty

Methods in io.grpc.netty that return Metadata

Modifier and Type	Method	Description
static Metadata	Utils.convertHeaders(io.netty.handler.codec.http2.Http2Headers http2Headers)
static Metadata	Utils.convertTrailers(io.netty.handler.codec.http2.Http2Headers http2Headers)

Methods in io.grpc.netty with parameters of type Metadata

Modifier and Type	Method	Description
static io.netty.handler.codec.http2.Http2Headers	Utils.convertClientHeaders(Metadata headers, io.netty.util.AsciiString scheme, io.netty.util.AsciiString defaultPath, io.netty.util.AsciiString authority, io.netty.util.AsciiString method, io.netty.util.AsciiString userAgent)
static io.netty.handler.codec.http2.Http2Headers	Utils.convertServerHeaders(Metadata headers)
static io.netty.handler.codec.http2.Http2Headers	Utils.convertTrailers(Metadata trailers, boolean headersSent)
protected void	NettyClientStream.TransportState.http2ProcessingFailed(Status status, boolean stopDelivery, Metadata trailers)
ClientStream	NettyClientTransport.newStream(MethodDescriptor<?,?> method, Metadata headers, CallOptions callOptions, ClientStreamTracer[] tracers)
void	NettyClientStream.Sink.writeHeaders(Metadata headers, byte[] requestPayload)
void	NettyServerStream.Sink.writeHeaders(Metadata headers, boolean flush)
private void	NettyClientStream.Sink.writeHeadersInternal(Metadata headers, byte[] requestPayload)
void	NettyServerStream.Sink.writeTrailers(Metadata trailers, boolean headersSent, Status status)

Constructors in io.grpc.netty with parameters of type Metadata

Modifier	Constructor	Description
(package private)	NettyClientStream(NettyClientStream.TransportState state, MethodDescriptor<?,?> method, Metadata headers, io.netty.channel.Channel channel, io.netty.util.AsciiString authority, io.netty.util.AsciiString scheme, io.netty.util.AsciiString userAgent, StatsTraceContext statsTraceCtx, TransportTracer transportTracer, CallOptions callOptions, boolean useGetForSafeMethods)

Uses of Metadata in io.grpc.protobuf

Methods in io.grpc.protobuf that return Metadata

Modifier and Type	Method	Description
private static Metadata	StatusProto.toMetadata(com.google.rpc.Status statusProto)
private static Metadata	StatusProto.toMetadata(com.google.rpc.Status statusProto, Metadata metadata)

Methods in io.grpc.protobuf with parameters of type Metadata

Modifier and Type	Method	Description
static com.google.rpc.Status	StatusProto.fromStatusAndTrailers(Status status, Metadata trailers)	Extracts the google.rpc.Status from trailers, and makes sure they match the gRPC status.
private static Metadata	StatusProto.toMetadata(com.google.rpc.Status statusProto, Metadata metadata)
static StatusException	StatusProto.toStatusException(com.google.rpc.Status statusProto, Metadata metadata)	Convert a Status instance to a StatusException with additional metadata.
static StatusException	StatusProto.toStatusException(com.google.rpc.Status statusProto, Metadata metadata, Throwable cause)	Convert a Status instance to a StatusException with additional metadata and the root exception thrown.
static StatusRuntimeException	StatusProto.toStatusRuntimeException(com.google.rpc.Status statusProto, Metadata metadata)	Convert a Status instance to a StatusRuntimeException with additional metadata.

Uses of Metadata in io.grpc.protobuf.services

Methods in io.grpc.protobuf.services with parameters of type Metadata

Modifier and Type	Method	Description
(package private) static BinlogHelper.MaybeTruncated<Metadata.Builder>	BinlogHelper.createMetadataProto(Metadata metadata, int maxHeaderBytes)
(package private) abstract void	BinlogHelper.SinkWriter.logClientHeader(long seq, String methodName, String authority, com.google.protobuf.Duration timeout, Metadata metadata, GrpcLogEntry.Logger logger, long callId, SocketAddress peerAddress)	Logs the client header.
(package private) void	BinlogHelper.SinkWriterImpl.logClientHeader(long seq, String methodName, String authority, com.google.protobuf.Duration timeout, Metadata metadata, GrpcLogEntry.Logger logger, long callId, SocketAddress peerAddress)
(package private) abstract void	BinlogHelper.SinkWriter.logServerHeader(long seq, Metadata metadata, GrpcLogEntry.Logger logger, long callId, SocketAddress peerAddress)	Logs the server header.
(package private) void	BinlogHelper.SinkWriterImpl.logServerHeader(long seq, Metadata metadata, GrpcLogEntry.Logger logger, long callId, SocketAddress peerAddress)
(package private) abstract void	BinlogHelper.SinkWriter.logTrailer(long seq, Status status, Metadata metadata, GrpcLogEntry.Logger logger, long callId, SocketAddress peerAddress)	Logs the server trailer.
(package private) void	BinlogHelper.SinkWriterImpl.logTrailer(long seq, Status status, Metadata metadata, GrpcLogEntry.Logger logger, long callId, SocketAddress peerAddress)
void	HealthCheckingLoadBalancerFactory.HealthCheckState.HcStream.onClose(Status status, Metadata trailers)

Uses of Metadata in io.grpc.rls

Methods in io.grpc.rls with parameters of type Metadata

Modifier and Type	Method	Description
(package private) RlsProtoData.RouteLookupRequest	RlsRequestFactory.create(String service, String method, Metadata metadata)	Creates a RlsProtoData.RouteLookupRequest for given request's metadata.
private com.google.common.collect.ImmutableMap.Builder<String,String>	RlsRequestFactory.createRequestHeaders(Metadata metadata, List<RlsProtoData.NameMatcher> keyBuilder)

Uses of Metadata in io.grpc.servlet

Methods in io.grpc.servlet that return Metadata

Modifier and Type	Method	Description
private static Metadata	ServletAdapter.getHeaders(javax.servlet.http.HttpServletRequest req)

Methods in io.grpc.servlet with parameters of type Metadata

Modifier and Type	Method	Description
void	ServletServerStream.Sink.writeHeaders(Metadata headers, boolean flush)
private void	ServletServerStream.writeHeadersToServletResponse(Metadata metadata)
void	ServletServerStream.Sink.writeTrailers(Metadata trailers, boolean headersSent, Status status)

Uses of Metadata in io.grpc.servlet.jakarta

Methods in io.grpc.servlet.jakarta that return Metadata

Modifier and Type	Method	Description
private static Metadata	ServletAdapter.getHeaders(jakarta.servlet.http.HttpServletRequest req)

Methods in io.grpc.servlet.jakarta with parameters of type Metadata

Modifier and Type	Method	Description
void	ServletServerStream.Sink.writeHeaders(Metadata headers, boolean flush)
private void	ServletServerStream.writeHeadersToServletResponse(Metadata metadata)
void	ServletServerStream.Sink.writeTrailers(Metadata trailers, boolean headersSent, Status status)

Uses of Metadata in io.grpc.stub

Fields in io.grpc.stub declared as Metadata

Modifier and Type	Field	Description
private final Metadata	MetadataUtils.HeaderAttachingClientInterceptor.extraHeaders
private final Metadata	MetadataUtils.MetadataAttachingServerInterceptor.extras

Fields in io.grpc.stub with type parameters of type Metadata

Modifier and Type	Field	Description
(package private) final AtomicReference<Metadata>	MetadataUtils.MetadataCapturingClientInterceptor.headersCapture
(package private) final AtomicReference<Metadata>	MetadataUtils.MetadataCapturingClientInterceptor.trailersCapture

Methods in io.grpc.stub with parameters of type Metadata

Modifier and Type	Method	Description
void	MetadataUtils.MetadataAttachingServerInterceptor.MetadataAttachingServerCall.close(Status status, Metadata trailers)
<ReqT, RespT> ServerCall.Listener<ReqT>	MetadataUtils.MetadataAttachingServerInterceptor.interceptCall(ServerCall<ReqT,RespT> call, Metadata headers, ServerCallHandler<ReqT,RespT> next)
static ClientInterceptor	MetadataUtils.newAttachHeadersInterceptor(Metadata extraHeaders)	Returns a client interceptor that attaches a set of headers to requests.
static ServerInterceptor	MetadataUtils.newAttachMetadataServerInterceptor(Metadata extras)	Returns a ServerInterceptor that adds the specified Metadata to every response stream, one way or another.
void	ClientCalls.BlockingResponseStream.QueuingListener.onClose(Status status, Metadata trailers)
void	ClientCalls.StreamObserverToCallListenerAdapter.onClose(Status status, Metadata trailers)
void	ClientCalls.UnaryStreamToFuture.onClose(Status status, Metadata trailers)
void	MetadataUtils.MetadataCapturingClientInterceptor.MetadataCapturingClientCall.MetadataCapturingClientCallListener.onClose(Status status, Metadata trailers)
void	ClientCalls.BlockingResponseStream.QueuingListener.onHeaders(Metadata headers)
void	ClientCalls.StreamObserverToCallListenerAdapter.onHeaders(Metadata headers)
void	ClientCalls.UnaryStreamToFuture.onHeaders(Metadata headers)
void	MetadataUtils.MetadataCapturingClientInterceptor.MetadataCapturingClientCall.MetadataCapturingClientCallListener.onHeaders(Metadata headers)
void	MetadataUtils.MetadataAttachingServerInterceptor.MetadataAttachingServerCall.sendHeaders(Metadata headers)
void	MetadataUtils.HeaderAttachingClientInterceptor.HeaderAttachingClientCall.start(ClientCall.Listener<RespT> responseListener, Metadata headers)
void	MetadataUtils.MetadataCapturingClientInterceptor.MetadataCapturingClientCall.start(ClientCall.Listener<RespT> responseListener, Metadata headers)
ServerCall.Listener<ReqT>	ServerCalls.StreamingServerCallHandler.startCall(ServerCall<ReqT,RespT> call, Metadata headers)
ServerCall.Listener<ReqT>	ServerCalls.UnaryServerCallHandler.startCall(ServerCall<ReqT,RespT> call, Metadata headers)

Method parameters in io.grpc.stub with type arguments of type Metadata

Modifier and Type	Method	Description
static ClientInterceptor	MetadataUtils.newCaptureMetadataInterceptor(AtomicReference<Metadata> headersCapture, AtomicReference<Metadata> trailersCapture)	Captures the last received metadata on a channel.

Constructors in io.grpc.stub with parameters of type Metadata

Modifier	Constructor	Description
(package private)	HeaderAttachingClientInterceptor(Metadata extraHeaders)
(package private)	MetadataAttachingServerInterceptor(Metadata extras)

Constructor parameters in io.grpc.stub with type arguments of type Metadata

Modifier	Constructor	Description
(package private)	MetadataCapturingClientInterceptor(AtomicReference<Metadata> headersCapture, AtomicReference<Metadata> trailersCapture)

Uses of Metadata in io.grpc.util

Methods in io.grpc.util with parameters of type Metadata

Modifier and Type	Method	Description
void	TransmitStatusRuntimeExceptionInterceptor.SerializingServerCall.close(Status status, Metadata trailers)
void	ForwardingClientStreamTracer.inboundHeaders(Metadata headers)
void	ForwardingClientStreamTracer.inboundTrailers(Metadata trailers)
<ReqT, RespT> ServerCall.Listener<ReqT>	TransmitStatusRuntimeExceptionInterceptor.interceptCall(ServerCall<ReqT,RespT> call, Metadata headers, ServerCallHandler<ReqT,RespT> next)
ClientStreamTracer	OutlierDetectionLoadBalancer.OutlierDetectionPicker.ResultCountingClientStreamTracerFactory.newClientStreamTracer(ClientStreamTracer.StreamInfo info, Metadata headers)
void	TransmitStatusRuntimeExceptionInterceptor.SerializingServerCall.sendHeaders(Metadata headers)
void	ForwardingClientStreamTracer.streamCreated(Attributes transportAttrs, Metadata headers)