server

type ExternalAuthZChecker func(ctx context.Context, authZReq ExternalAuthZRequest) (bool, error)

type ExternalAuthZRequest interface{}

type ExternalAuthZRequestGetter interface {
	// GetAuthZRequest is invoked by the authZ interceptor before performing an authZ check.
	// Returns an auth request that will be passed to ExternalAuthZChecker function to authorize
	// the specified input API request. Optionally, returns handler-data to be stashed in the context
	// for the later retrieval by the handler. The first return param can have following special values:
	// - Return InsecureNoAuthNAuthZ to skip both authN and authZ completely.
	// - Return InsecureNoAuthZ to perform just an authN check for a specific request and skip authZ check.
	// Such insecure requests must also be whilelisted in insecureNoAuthNAuthZReqs or insecureNoAuthZReqs params.
	// ExternalAuthZChecker function is not invoked for the insecure requests.
	GetAuthZRequest(ctx context.Context, fullPath string, request interface{}) (ExternalAuthZRequest, HandlerData, error)
}

type GrpcFrameworkServer struct {
	*grpcserver.GrpcServer
	// contains filtered or unexported fields
}

type HandlerData interface{}

type RateLimiter interface {
	Allow() bool
}

type RateLimiterConfig struct {
	RateLimiter        RateLimiter
	RateLimiterPerUser RateLimiter
}

type RestGateway struct {
	// contains filtered or unexported fields
}

type RestServerConfig struct {
	Enabled          bool
	Port             string
	CorsOptions      RestServerCorsConfig
	PrometheusConfig RestServerPrometheusConfig
}

type RestServerCorsConfig struct {
	Enabled bool

	// If not set, the framework will set up the cors
	CustomOptions *cors.Options
}

type RestServerPrometheusConfig struct {
	Enabled bool

	// Defaults to `/metrics` if not provided
	Path string
}

type SecurityConfig struct {
	// Role implementation
	Role role.RoleManager
	// Tls configuration
	Tls *TLSConfig
	// Authenticators is a map of Authenticators by issuer which is key in the map.
	// If there are multiple authenticators with the same issuer (e.g. using different
	// client IDs), use NewIteratingMultiAuthenticator or NewMultiAuthenticatorByClientID and
	// then, add the returned multi-authenticator to this map.
	Authenticators map[string]auth.Authenticator
}

type Server struct {
	// contains filtered or unexported fields
}

type ServerConfig struct {
	// Name of the server
	Name string
	// Net is the transport for gRPC: unix, tcp, etc.
	// Defaults to `tcp` if the value is not provided.
	Net string
	// Address is the port number or the unix domain socket path.
	// For the gRPC Server. This value goes together with `Net`.
	Address string
	// REST server configuration
	RestConfig RestServerConfig
	// Unix domain socket for local communication. This socket
	// will be used by the REST Gateway to communicate with the gRPC server.
	// Only set for testing. Having a '%s' can be supported to use the
	// name of the driver as the driver name.
	Socket string
	// (optional) Location for audit log.
	// If not provided, it will go to /var/log/openstorage-audit.log
	AuditOutput io.Writer
	// (optional) Location of access log.
	// This is useful when authorization is not running.
	// If not provided, it will go to /var/log/grpc-framework-access.log
	AccessOutput io.Writer
	// Security configuration
	Security *SecurityConfig
	// RateLimiters provide caller with the ability to setup rate limits for
	// the gRPC server
	RateLimiters RateLimiterConfig
	// ServerExtensions allows you to extend the SDK gRPC server
	// with callback functions that are sequentially executed
	// at the end of Server.Start()
	//
	// To add your own service to the SDK gRPC server,
	// just append a function callback that registers it:
	//
	// s.config.ServerExtensions = append(s.config.ServerExtensions,
	// 		func(gs *grpc.Server) {
	//			api.RegisterCustomService(gs, customHandler)
	//		})
	GrpcServerExtensions []func(grpcServer *grpc.Server)

	// RestServerExtensions allows for extensions to be added
	// to the SDK Rest Gateway server.
	//
	// To add your own service to the SDK REST Server, simply add your handlers
	// to the RestSererExtensions slice. These handlers will be registered on the
	// REST Gateway http server.
	RestServerExtensions []func(context.Context, *runtime.ServeMux, *grpc.ClientConn) error

	// UnaryServerInterceptors will be interceptors added to the end of the default chain
	UnaryServerInterceptors []grpc.UnaryServerInterceptor

	// StreamServerInterceptors will be interceptors added to the end of the default chain
	StreamServerInterceptors []grpc.StreamServerInterceptor

	// ServerOptions hold any special gRPC server options
	ServerOptions []grpc.ServerOption

	// AuthNUnaryInterceptor installs a custom authN unary interceptor and overrides the default one
	AuthNUnaryInterceptor grpc.UnaryServerInterceptor

	// AuthNStreamInterceptor installs a custom authN stream interceptor and overrides the default one
	AuthNStreamInterceptor grpc.StreamServerInterceptor

	// AuthZUnaryInterceptor installs a custom authZ unary interceptor and overrides the default one
	AuthZUnaryInterceptor grpc.UnaryServerInterceptor

	// AuthZStreamInterceptor installs a custom authZ stream interceptor and overrides the default one
	AuthZStreamInterceptor grpc.StreamServerInterceptor

	// ExternalAuthZChecker plugs into the external authorizer framework's authZ interceptor
	ExternalAuthZChecker ExternalAuthZChecker

	// InsecureNoAuthNAuthZReqs is a list of API request types for which AuthN
	// or AuthZ checks are skipped.  When
	// ExternalAuthZRequestGetter.GetAuthZRequest() returns
	// InsecureNoAuthNAuthZ, the framework ensures that the request type is also
	// present in InsecureNoAuthNAuthZReqs  list. This adds a second level of
	// confirmation that it is ok to skip the auth checks for this request.
	// Refer to the documentation of ExternalAuthZRequestGetter interface for
	// more details.
	InsecureNoAuthNAuthZReqs []interface{}

	// InsecureNoAuthZReqs is data passed by the caller for the caller's
	// interceptor containing information on what APIs to not check for
	// authorization
	InsecureNoAuthZReqs []interface{}
}

type TLSConfig struct {
	// CertFile is the path to the cert file
	CertFile string
	// KeyFile is the path to the key file
	KeyFile string
}