auth

Documentation

Index

• type AuthenticateArgs
• type AuthenticateReply
• type ConfigureArg
• type ConfigureReply
• type CredentialStrategy
• type Credentials
• type Manager
• type ProviderPlugin
  • func (p *ProviderPlugin) Client(b *hcplugin.MuxBroker, c *rpc.Client) (interface{}, error)
  • func (p *ProviderPlugin) Server(*hcplugin.MuxBroker) (interface{}, error)
• type RPCClient
  • func (m *RPCClient) Authenticate(ctx context.Context, clientID, clientSecret string) (*user.User, map[string]*authpb.Scope, error)
  • func (m *RPCClient) Configure(ml map[string]interface{}) error
• type RPCServer
  • func (m *RPCServer) Authenticate(args AuthenticateArgs, resp *AuthenticateReply) error
  • func (m *RPCServer) Configure(args ConfigureArg, resp *ConfigureReply) error
• type Registry
• type TokenStrategy
• type TokenWriter

Types

type AuthenticateArgs

type AuthenticateArgs struct {
	Ctx          map[interface{}]interface{}
	ClientID     string
	ClientSecret string
}

AuthenticateArgs for RPC

type AuthenticateReply

type AuthenticateReply struct {
	User  *user.User
	Auth  map[string]*authpb.Scope
	Error error
}

AuthenticateReply for RPC

type ConfigureArg

type ConfigureArg struct {
	Ml map[string]interface{}
}

ConfigureArg for RPC

type ConfigureReply

type ConfigureReply struct {
	Err error
}

ConfigureReply for RPC

type CredentialStrategy

type CredentialStrategy interface {
	GetCredentials(w http.ResponseWriter, r *http.Request) (*Credentials, error)
	AddWWWAuthenticate(w http.ResponseWriter, r *http.Request, realm string)
}

CredentialStrategy obtains Credentials from the request.

type Credentials

type Credentials struct {
	Type         string
	ClientID     string
	ClientSecret string
}

Credentials contains the auth type, client id and secret.

type Manager

type Manager interface {
	plugin.Plugin
	Authenticate(ctx context.Context, clientID, clientSecret string) (*user.User, map[string]*authpb.Scope, error)
}

Manager is the interface to implement to authenticate users

type ProviderPlugin

type ProviderPlugin struct {
	Impl Manager
}

ProviderPlugin is the implementation of plugin.Plugin so we can serve/consume this.

func (*ProviderPlugin) Client

func (p *ProviderPlugin) Client(b *hcplugin.MuxBroker, c *rpc.Client) (interface{}, error)

Client returns interface implementation for the plugin that communicates to the server end of the plugin

func (*ProviderPlugin) Server

func (p *ProviderPlugin) Server(*hcplugin.MuxBroker) (interface{}, error)

Server returns the RPC Server which serves the methods that the Client calls over net/rpc

type RPCClient

type RPCClient struct{ Client *rpc.Client }

RPCClient is an implementation of Manager that talks over RPC.

func (*RPCClient) Authenticate

func (m *RPCClient) Authenticate(ctx context.Context, clientID, clientSecret string) (*user.User, map[string]*authpb.Scope, error)

Authenticate RPCClient Authenticate method

func (*RPCClient) Configure

func (m *RPCClient) Configure(ml map[string]interface{}) error

Configure RPCClient configure method

type RPCServer

type RPCServer struct {
	// This is the real implementation
	Impl Manager
}

RPCServer is the server that RPCClient talks to, conforming to the requirements of net/rpc

func (*RPCServer) Authenticate

func (m *RPCServer) Authenticate(args AuthenticateArgs, resp *AuthenticateReply) error

Authenticate RPCServer Authenticate method

func (*RPCServer) Configure

func (m *RPCServer) Configure(args ConfigureArg, resp *ConfigureReply) error

Configure RPCServer Configure method

type Registry

type Registry interface {
	ListProviders(ctx context.Context) ([]*registry.ProviderInfo, error)
	GetProvider(ctx context.Context, authType string) (*registry.ProviderInfo, error)
}

Registry is the interface that auth registries implement for discovering auth providers

type TokenStrategy

type TokenStrategy interface {
	GetToken(r *http.Request) string
}

TokenStrategy obtains a token from the request. If token does not exist returns an empty string.

type TokenWriter

type TokenWriter interface {
	WriteToken(token string, w http.ResponseWriter)
}

TokenWriter stores the token in a http response.