All Classes and Interfaces
Class
Description
A call listener that will set the authentication context before each invocation and clear it afterwards.
Abstract implementation of
GrpcSecurityMetadataSource which resolves the secured object type to a
ServerCall.Abstract factory for grpc servers.
Predicate that can be used to check whether the given
Authentication has access to the protected
service/method.Some helper methods used to create
Predicates for SocketAddresses.A
ConfigAttribute which uses the embedded AccessPredicate for the decisions.An
AccessDecisionVoter that checks for AccessPredicateConfigAttributes.Automatically find and configure
annotated global ServerInterceptors.A
GrpcServiceDiscoverer that searches for beans with the GrpcService annotations.The AnonymousAuthenticationReader allows users without credentials to get an anonymous identity.
Marker-Interface: A server interceptor that used to authenticate the client request.
A server interceptor that will check the security context whether it has permission to access the grpc method.
Reads
basic auth credentials from the request.Spring-Security has several token-based
AuthenticationProvider implementations (e.g.Indicates the state of the
SSLEngine with respect to client authentication.Combines multiple
GrpcAuthenticationReader into a single one.A condition that matches if the
grpc.server.port does not have the value -1.A server interceptor that tries to
read the credentials from the client and
authenticate them.Server interceptor that translates any
AuthenticationException and AccessDeniedException to
appropriate grpc status responses.A bean that can be used to configure global
ServerInterceptors.The global server interceptor registry keeps references to all
ServerInterceptors that should be registered
to all server channels.Special
@Component to declare global gRPC exception handling.The auto configuration that will create necessary beans to provide a proper exception handling via annotations
@GrpcAdvice and @GrpcExceptionHandler.A discovery class to find all Beans annotated with
@GrpcAdvice and for all found beans a second
search is performed looking for methods with @GrpcExceptionHandler.As part of
@GrpcAdvice, when a thrown exception is caught during gRPC calls (via global
interceptor GrpcExceptionInterceptor), then this thrown exception is being handled.Condition to check if
@GrpcAdvice is present.Reads the authentication data from the given
ServerCall and Metadata.Methods annotated with
@GrpcExceptionHandler are being mapped to a corresponding
Exception, by declaring either in @GrpcExceptionHandler(value = ...) as value or
as annotated methods parameter (both is working too).Given an annotated
@GrpcAdvice class and annotated methods with
@GrpcExceptionHandler, GrpcExceptionHandlerMethodResolver resolves given
exception type and maps it to the corresponding method to be executed, when this exception is being raised.Interceptor to use for global exception handling.
ServerCall.Listener for server side exception handling.An exception handler for errors in the grpc call execution (For both the grpc method implementations and the
StreamObservers used to process incoming messages and sending outgoing errors).Specialized
ServerCall for server side exception handling.Annotation for gRPC
ServerInterceptors to apply them globally.Auto configuration that sets up the grpc health service.
Configuration class that configures the required beans for gRPC discovery via Consul.
Configuration class that configures the required beans for grpc discovery via Eureka.
Configuration class that configures the required beans for grpc discovery via Nacos.
Configuration class that configures the required beans for grpc discovery via Zookeeper.
Auto configuration that sets up the proto reflection service.
The scope for beans that have their lifecycle bound to the grpc
Context.A
SecurityMetadataSource for grpc requests.The auto configuration used by Spring-Boot that contains all beans to run a grpc server/service.
A configurer for
ServerBuilders which can be used by GrpcServerFactory to customize the created
server.A factory that can be used to create grpc servers.
The auto configuration that will create the
GrpcServerFactorys and GrpcServerLifecycles, if the
developer hasn't specified their own variant.Lifecycle bean that automatically starts and stops the grpc server.
The base event for
GrpcServerLifecycle.Auto configuration class for Spring-Boot.
The configuration used to configure micrometer tracing for grpc.
The properties for the gRPC server that will be started as part of the application.
The security configuration for the gRPC server.
Auto configuration class with the required beans for the spring-security configuration of the grpc server.
This event will be fired before the server starts to shutdown.
This event will be fired after the server has been started.
This event will be fired after the server completed to shutdown.
Annotation that marks gRPC services that should be registered with a gRPC server.
Container class that contains all relevant information about a grpc service.
An interface for a bean that will be used to find grpc services and codecs.
Factory for in process grpc servers.
A
GrpcSecurityMetadataSource for manual configuration.Provides factories for
StreamTracer that records metrics.Factory for netty based grpc servers.
Deprecated.
A
NameResolver that will always respond with the server's own address.A name resolver factory that will create a
SelfNameResolverFactory based on the target uri.Factory for shaded netty based grpc servers.
An
GrpcAuthenticationReader that will try to use the peer certificates to extract the client
Authentication.An authentication object that was created for a
X509Certificate.An
AuthenticationProvider for X509Certificates.
ServerInterceptorin combination withOrder(either on the target class itself or the related factory method).