environment

type CleanupOpts struct {
	// FlowOfNamePredicate returns true if in the context of Bifröst
	// there exists another flow with this name.
	FlowOfNamePredicate func(configuration.FlowName) (bool, error)

	// SessionExists returns true if the given session (by its [session.Id]) does
	// exist within the whole Bifröst context.
	SessionExists func(context.Context, configuration.FlowName, session.Id) (bool, error)

	// Logger will be used (if any log is required) instead of the standard logger.
	Logger log.Logger
}

type CloseableRepository interface {
	Repository
	io.Closer
}

type Context interface {
	Connection() connection.Connection
	Context() essh.Context
	Authorization() authorization.Authorization
}

type ContextualSessionCompatibilityChecker interface {
	IsSessionCompatibleWith(Context, session.Session) (bool, error)
}

type DockerRepository struct {
	Logger log.Logger
	// contains filtered or unexported fields
}

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

type Environment interface {
	Banner(Request) (io.ReadCloser, error)
	Run(Task) (int, error)

	IsPortForwardingAllowed(net.HostPort) (bool, error)
	NewDestinationConnection(context.Context, net.HostPort) (io.ReadWriteCloser, error)

	// Dispose will fully dispose this instance.
	// It does also implicitly call Close() to ensure everything happens
	// in the correct synchronized context.
	Dispose(context.Context) (bool, error)

	// Close can be safely called more than once.
	Close() error
}

type FindOpts struct {
	// ExpectedResource prevents cleanup or reuse if the inspected resource was replaced.
	ExpectedResource *ResourceIdentity

	// AutoCleanUpAllowed tells the repository to clean up everything
	// automatically while executing the search. The requester will never
	// see the requested result. This is false by default because it could
	// lead to quite performance impacts or other unwanted side effects.
	//
	// Therefore: Use with caution.
	AutoCleanUpAllowed *bool

	// Logger will be used (if any log is required) instead of the standard logger.
	Logger log.Logger
}

type ImpProtocolCompatibilityChecker interface {
	ImpProtocolCompatibility(context.Context, session.Session) (compatible bool, found bool, revision uint32, identity ResourceIdentity, err error)
}

type KubernetesRepository struct {
	Logger log.Logger
	// contains filtered or unexported fields
}

type LocalRepository struct {
	Logger log.Logger
	// contains filtered or unexported fields
}

type PreparationProgress interface {
	Report(progress float32) error
	Done() error
	Error(error) error
}

type PreparationProgressAttributes map[string]any

type PreparationProgressEnabled interface {
	StartPreparation(id, title string, attrs PreparationProgressAttributes) (PreparationProgress, error)
}

type Repository interface {
	// WillBeAccepted returns true if it is possible to get an Environment for the
	// provided Request.
	WillBeAccepted(Context) (bool, error)

	// DoesSupportPty will return true if the resulting Environment will support
	// an PTY.
	DoesSupportPty(Context, essh.Pty) (bool, error)

	// Ensure will create or return an environment that matches the given Request.
	// If it is not acceptable to do this action with the provided Request
	// ErrNotAcceptable is returned; you can call WillBeAccepted to prevent such
	// errors.
	Ensure(Request) (Environment, error)

	// FindBySession will find an existing environment for a given session.Session.
	// If there is no matching one ErrNoSuchEnvironment will be returned.
	FindBySession(context.Context, session.Session, *FindOpts) (Environment, error)

	// Cleanup can be called while housekeeping iteration. It will also forward
	// all otherFlows that are configured within Bifröst. This gives the Repository
	// to potentially cleanup orphan resources that where initially owned by another
	// flow.
	Cleanup(context.Context, *CleanupOpts) error
}

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

type RepositoryFactory[C any, R CloseableRepository] func(context.Context, configuration.FlowName, C, alternatives.Provider, imp.Imp) (R, error)

type Request interface {
	Context
	PreparationProgressEnabled
}

type ResourceIdentity struct {
	DockerID            string
	KubernetesNamespace string
	KubernetesName      string
	KubernetesUID       string
}

type ReversePortForwardingPolicy interface {
	IsReversePortForwardingAllowed(net.HostPort) (bool, error)
}

type ReverseTCPListener interface {
	ListenReverseTCP(context.Context, string, uint16) (gonet.Listener, error)
}

type SessionCompatibilityChecker interface {
	IsSessionCompatible(context.Context, session.Session) (bool, error)
}

type SshRepository struct {
	Logger log.Logger
	// contains filtered or unexported fields
}

type SubsystemRunner interface {
	RunSubsystem(Task, func(bool) error) (int, error)
}

type Task interface {
	Context
	SshSession() essh.Session
	TaskType() TaskType
}

type TaskType uint8