server

Documentation

Index

• type AgentTokenAuthenticationOptions
• type Backend
• type BackendManager
• type DefaultBackendManager
  • func NewDefaultBackendManager() *DefaultBackendManager
  • func (s *DefaultBackendManager) AddBackend(agentID string, conn agent.AgentService_ConnectServer)
  • func (s *DefaultBackendManager) Backend() (Backend, error)
  • func (s *DefaultBackendManager) Ready() (bool, string)
  • func (s *DefaultBackendManager) RemoveBackend(agentID string, conn agent.AgentService_ConnectServer)
• type ErrNotFound
  • func (e *ErrNotFound) Error() string
• type PendingDialManager
  • func NewPendingDialManager() *PendingDialManager
  • func (pm *PendingDialManager) Add(random int64, clientConn *ProxyClientConnection)
  • func (pm *PendingDialManager) Get(random int64) (*ProxyClientConnection, bool)
  • func (pm *PendingDialManager) Remove(random int64)
• type ProxyClientConnection
• type ProxyServer
  • func NewProxyServer(serverID string, serverCount int, ...) *ProxyServer
  • func (s *ProxyServer) Connect(stream agent.AgentService_ConnectServer) error
  • func (s *ProxyServer) Proxy(stream client.ProxyService_ProxyServer) error
• type ReadinessManager
• type Tunnel
  • func (t *Tunnel) ServeHTTP(w http.ResponseWriter, r *http.Request)

Types

type AgentTokenAuthenticationOptions

type AgentTokenAuthenticationOptions struct {
	Enabled                bool
	AgentNamespace         string
	AgentServiceAccount    string
	AuthenticationAudience string
	KubernetesClient       kubernetes.Interface
}

AgentTokenAuthenticationOptions contains list of parameters required for agent token based authentication

type Backend

type Backend interface {
	Send(p *client.Packet) error
	Context() context.Context
}

type BackendManager

type BackendManager interface {
	// Backend returns a single backend.
	Backend() (Backend, error)
	// AddBackend adds a backend.
	AddBackend(agentID string, conn agent.AgentService_ConnectServer)
	// RemoveBackend removes a backend.
	RemoveBackend(agentID string, conn agent.AgentService_ConnectServer)
}

BackendManager is an interface to manage backend connections, i.e., connection to the proxy agents.

type DefaultBackendManager

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

DefaultBackendManager is the default backend manager.

func NewDefaultBackendManager

func NewDefaultBackendManager() *DefaultBackendManager

NewDefaultBackendManager returns a DefaultBackendManager.

func (*DefaultBackendManager) AddBackend

func (s *DefaultBackendManager) AddBackend(agentID string, conn agent.AgentService_ConnectServer)

AddBackend adds a backend.

func (*DefaultBackendManager) Backend

func (s *DefaultBackendManager) Backend() (Backend, error)

Backend returns a random backend.

func (*DefaultBackendManager) Ready

func (s *DefaultBackendManager) Ready() (bool, string)

func (*DefaultBackendManager) RemoveBackend

func (s *DefaultBackendManager) RemoveBackend(agentID string, conn agent.AgentService_ConnectServer)

RemoveBackend removes a backend.

type ErrNotFound

type ErrNotFound struct{}

ErrNotFound indicates that no backend can be found.

func (*ErrNotFound) Error

func (e *ErrNotFound) Error() string

Error returns the error message.

type PendingDialManager

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

func NewPendingDialManager

func NewPendingDialManager() *PendingDialManager

func (*PendingDialManager) Add

func (pm *PendingDialManager) Add(random int64, clientConn *ProxyClientConnection)

func (*PendingDialManager) Get

func (pm *PendingDialManager) Get(random int64) (*ProxyClientConnection, bool)

func (*PendingDialManager) Remove

func (pm *PendingDialManager) Remove(random int64)

type ProxyClientConnection

type ProxyClientConnection struct {
	Mode string
	Grpc client.ProxyService_ProxyServer
	HTTP net.Conn
	// contains filtered or unexported fields
}

ProxyClientConnection...

type ProxyServer

type ProxyServer struct {
	// BackendManager manages the backends.
	BackendManager BackendManager

	// Readiness reports if the proxy server is ready, i.e., if the proxy
	// server has connections to proxy agents (backends). Note that the
	// proxy server does not check the healthiness of the connections,
	// though the proxy agents do, so this readiness check might report
	// ready but there is no healthy connection.
	Readiness ReadinessManager

	PendingDial *PendingDialManager

	// agent authentication
	AgentAuthenticationOptions *AgentTokenAuthenticationOptions
	// contains filtered or unexported fields
}

ProxyServer

func NewProxyServer

func NewProxyServer(serverID string, serverCount int, agentAuthenticationOptions *AgentTokenAuthenticationOptions) *ProxyServer

NewProxyServer creates a new ProxyServer instance

func (*ProxyServer) Connect

func (s *ProxyServer) Connect(stream agent.AgentService_ConnectServer) error

Connect is for agent to connect to ProxyServer as next hop

func (*ProxyServer) Proxy

func (s *ProxyServer) Proxy(stream client.ProxyService_ProxyServer) error

Proxy handles incoming streams from gRPC frontend.

type ReadinessManager

type ReadinessManager interface {
	// Ready returns if the proxy server is ready. If not, also return an
	// error message.
	Ready() (bool, string)
}

ReadinessManager supports checking if the proxy server is ready.

type Tunnel

type Tunnel struct {
	Server *ProxyServer
}

Tunnel implements Proxy based on HTTP Connect, which tunnels the traffic to the agent registered in ProxyServer.

func (*Tunnel) ServeHTTP

func (t *Tunnel) ServeHTTP(w http.ResponseWriter, r *http.Request)