browsersession

type Backend ¶

type Backend interface {
	Put(ctx context.Context, key string, record Record) error
	Get(ctx context.Context, key string) (Record, error)
	// Revoke invalidates key.  It is idempotent, which makes logout safe to
	// retry.  expiresAt is the horizon past which the implementation may drop
	// any tombstone it keeps.
	Revoke(ctx context.Context, key string, expiresAt time.Time) error
}

Backend is the authoritative store for session records. Implementations are keyed by an opaque, already-hashed lookup key and must be safe for concurrent use.

Get reports ErrNotFound, ErrExpired, or ErrRevoked; any other error is treated as a store failure and fails the request closed.

type Config ¶

type Config struct {
	TTL        time.Duration
	MaxEntries int
	Now        func() time.Time
	Random     io.Reader
	// Backend, when set, replaces the process-local memory backend.  Required
	// for a hub running more than one replica.
	Backend Backend
}

Config configures a Store. Now and Random are test seams; production uses time.Now and crypto/rand.Reader. MaxEntries bounds the default in-memory backend so an unbounded stream of logins cannot grow it indefinitely; it is ignored when Backend is supplied.

type Identity ¶

type Identity struct {
	UserID string
	Email  string
	Name   string
	// RBACIdentity is the kcp username this account authenticates as inside
	// tenant workspaces (User.Spec.RBACIdentity, e.g. "railgrid:<email>"). All
	// workspace RBAC — admin ClusterRoleBindings and app-access grants — is
	// written against this string, so authorization checks (SAR) must use it,
	// never the User CR name. Not a credential.
	RBACIdentity string
	Issuer       string
	Subject      string
	AuthType     string
}

Identity is the minimum server-side identity needed by hub and provider authorization. Credentials, ID tokens, refresh tokens, and kubeconfigs are intentionally not representable here.

type Record ¶

type Record struct {
	Identity  Identity
	IssuedAt  time.Time
	ExpiresAt time.Time
}

Record is what a Backend persists for one session. The raw opaque handle is returned transiently to the caller that needs to set a cookie; a Backend only ever sees the hash-derived key, never the handle itself.

type Session ¶

type Session struct {
	ID        string
	Identity  Identity
	IssuedAt  time.Time
	ExpiresAt time.Time
}

Session is the server-side representation associated with the opaque browser cookie. ID is returned to trusted hub callers for diagnostics; it is never serialized into the cookie itself.

type Store ¶

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

Store is the concurrency-safe front end for browser sessions: it owns handle generation, the cookie contract, and TTL policy, and delegates record storage to a Backend.

func New(config Config) *Store

func (s *Store) Issue(ctx context.Context, identity Identity) (string, Session, error)

func (s *Store) IssueHTTP(ctx context.Context, w http.ResponseWriter, identity Identity) (Session, error)

func (s *Store) IssueTransient(ctx context.Context, identity Identity, ttl time.Duration) (string, Session, error)

func (s *Store) Resolve(ctx context.Context, value string) (Session, error)

func (s *Store) ResolveRequest(r *http.Request) (Session, error)

func (s *Store) Revoke(ctx context.Context, value string) error

func (s *Store) RevokeRequest(w http.ResponseWriter, r *http.Request)

func (s *Store) TTL() time.Duration