runtime

type ComposeStack struct {
	Instance *components.Instance
	// contains filtered or unexported fields
}

type Container struct {
	Instance *components.Instance
	// contains filtered or unexported fields
}

type Credentials struct {
	User     string
	Password string
}

type DatabaseOptions struct {
	// Network is the block's private network. Required when any server is needed.
	Network *Network

	// RepoRoot resolves the repo-relative schema paths a component registers.
	RepoRoot string

	// Requests is each component's storage need.
	Requests []Request

	// LogWriter, when non-nil, receives each started server's output for the block that
	// owns it. A database server belongs to exactly one block, so the block's own writer
	// is its correct destination.
	LogWriter *logcapture.Writer
}

type Deps struct {
	// RepoRoot resolves repo-relative paths.
	RepoRoot string

	// Steps constructs runner-isolated step definitions.
	Steps StepFactory

	// FeatureRoot resolves the feature paths in the suite file.
	FeatureRoot string

	// Logger receives engine diagnostics.
	Logger *slog.Logger

	// CleanupDeleters registers how to delete each resource kind. Called per runner, so
	// each gets a registry wired with the suite's deleters.
	CleanupDeleters func(*cleanup.Registry, *Topology)

	// Coverage, when non-nil, makes every block harvest its containers' coverage
	// counters at teardown. Nil in a default run — the suite decides, because only it
	// knows whether the images are instrumented.
	Coverage *coverage.Sink

	// Logs, when non-nil, makes every block stream its containers' combined stdout/stderr
	// into one file for the block's whole lifetime. Nil in a default run — the suite
	// decides whether container output is being collected at all.
	Logs *logcapture.Sink
}

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

type InstanceKey string

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

type Options struct {
	// Network is the block's private network. Required.
	Network *Network

	// Ordinal and Replicas position this instance among its component's replicas.
	Ordinal  int
	Replicas int

	// Env is merged over the definition's static Env. This is where a resolved DSN
	// and any wiring-derived values arrive.
	Env map[string]string

	// ConfigContent is the assembled configuration file. When non-nil it is copied to
	// the definition's ConfigInjection.ContainerPath before start, because the
	// products read configuration once at boot.
	ConfigContent []byte

	// Files are extra host files to copy in, resolved to absolute paths already.
	Files []components.FileMount

	// RepoRoot resolves the relative paths in the definition's Files.
	RepoRoot string

	// StartTimeout overrides defaultStartTimeout.
	StartTimeout time.Duration

	// Arch overrides the detected architecture, for testing image substitution.
	Arch string

	// StableHostPorts publishes endpoints on explicitly selected host ports. It is required
	// for components that may be attached to multiple networks during their lifetime.
	StableHostPorts bool

	// LogWriter, when non-nil, receives this container's stdout/stderr for the whole
	// container lifetime, tagged with the component's name. Nil in a default run — the
	// suite decides whether container output is being collected at all.
	LogWriter *logcapture.Writer

	// SharedLogs, when non-nil, is the run-scoped sink LaunchShared writes a shared
	// component's output to. A shared component outlives every block, so LogWriter — which
	// belongs to one block — is the wrong destination for it.
	SharedLogs *logcapture.Sink
}

type Phase int

type Plan struct {
	// Servers is one entry per non-embedded engine used in the block, sorted by type
	// for determinism.
	Servers []Server

	// Stores is every logical database, sorted by ID.
	Stores map[StoreID]*Store

	// Assignments maps each component instance to the store it connects to.
	Assignments map[InstanceKey]StoreID
}

type Prober interface {
	// Probe returns the observed status, or an error if the attempt could not be made
	// at all (connection refused during warm-up, for instance).
	Probe(ctx context.Context, url string) (int, error)
}

type Provisioned struct {
	// Servers are the started database containers, keyed by engine, so the block can
	// stop them at teardown.
	Servers map[components.DBType]*Container

	// Env is the environment to merge into each component instance, keyed by instance.
	// Already rendered through each component's own naming convention.
	Env map[InstanceKey]map[string]string

	// Credentials are the block's generated credentials, exposed for diagnostics and
	// for steps that must connect to a store directly.
	Credentials Credentials

	// Plan is the layout that was provisioned.
	Plan *Plan
}

type Request struct {
	Def      *components.Definition
	Type     components.DBType
	Image    components.ImageRef
	Replicas int
}

type Server struct {
	// Type is the engine.
	Type components.DBType
	// Image is the selected server image. An empty value uses the runtime default.
	Image components.ImageRef
	// Stores are the logical databases to create on it.
	Stores []StoreID
}

type StepFactory func(topo *Topology) (StepRegistrar, error)

type StepRegistrar func(sc *godog.ScenarioContext)

type Store struct {
	ID StoreID

	// Type is the engine backing this store.
	Type components.DBType

	// Database is the generated physical name.
	Database string

	// Owner is the component whose schema this store carries.
	Owner string

	// OwnerOrdinal distinguishes stores when the owner has replicas.
	OwnerOrdinal int

	// Schema is the DDL the framework must apply, in order. Empty when the owner
	// migrates itself or the engine needs no schema.
	Schema []string

	// Embedded is true when the engine lives inside the owning component's container
	// and so needs no server of its own.
	Embedded bool
}

type StoreID string

type Topology struct {
	// Block is the resolved declaration this came from.
	Block *topology.ResolvedBlock

	// PropagationTimeout bounds asynchronous propagation waits for steps using this topology.
	PropagationTimeout time.Duration

	// Instances are the running components, addressable by name.
	Instances *components.Set

	// Admin are the fixed administrative credentials supplied by the test overlays.
	Admin actor.Credentials

	// Shared is the block's shared scope, already populated.
	Shared *tcontext.Shared

	// Storage is what the database layer provisioned.
	Storage *Provisioned
	// contains filtered or unexported fields
}