app

type BootLogger ¶

type BootLogger interface {
	BootLogger() *zap.Logger
}

BootLogger supplies the host's structured diagnostic logger before the runtime event bus exists. Hosts that omit it keep ordinary silent startup.

type Bundle ¶

type Bundle struct {
	Root  string
	Packs []Pack
}

Bundle is the complete offline deployment shipped by an executable. Root selects the application; other packs are its locked dependencies.

func (bundle Bundle) ID() string

func (bundle Bundle) Seed(directory string) (string, error)

type Executable ¶

type Executable struct {
	Data         map[string]string
	Host         Host
	LuaCacheSeed *LuaCacheSeed
	Name         string
	Command      string
	Components   []boot.Component
	// State is the default state directory when the invocation names none. A
	// relative path resolves against the working directory, so each folder
	// holds its own state. Empty selects the user configuration directory.
	State string
	// OwnedCommand, when set, runs that application command in a transient
	// state if acquiring the selected state's lock returns ErrOwned. It applies
	// only to run, after host planning; a plan's Run or Transient takes precedence.
	// Empty preserves the ordinary refusal. No owner readiness or IPC is implied.
	OwnedCommand string
	Bundle       Bundle
}

Executable is the complete declaration of a native Wippy application.

Name       addresses the default state directory, ^[a-z][a-z0-9_-]*$
Command    the application command an ordinary start runs
Bundle     the packs the executable ships, immutable
Data       application-owned environment variables bound to paths inside
           the state directory; a variable the environment already carries
           is a user override and keeps its value
Components the native components the host adds to the runtime
Host       decides what an invocation does, optional

The declaration order below follows the memory layout the runtime pins.

type Host ¶

type Host interface {
	Plan(ctx context.Context, l Launch) (Plan, error)
}

Host decides what an invocation does before the runner opens the state.

type Launch ¶

type Launch struct {
	Command  string
	State    string
	Dir      string
	Args     []string
	Op       Op
	Explicit bool
}

Launch describes one invocation to the host. State is already resolved and absolute, and Explicit reports that --state selected it. Owned answers whether a state has an owner, including a state the host selects itself.

type LuaCacheSeed ¶

type LuaCacheSeed struct {
	Digest            string
	SchemaVersion     string
	ToolchainIdentity string
	Archive           []byte
}

LuaCacheSeed is a cache snapshot created while assembling an application: a zip archive with one compressed member per cache file. The archive digest covers every embedded cache file.

type Op ¶

type Op int

Op is the operation an invocation selects.

const (
	OpRun Op = iota
	OpUpdate
	OpRecover
	OpWippy
)

func (op Op) String() string

type Pack ¶

type Pack struct {
	Module  string
	Version string
	Digest  string
	Data    []byte
}

Pack is an exact published artifact, including its Hub identity. Digest is the SHA-256 of Data, with a sha256: prefix.

type Plan ¶

type Plan struct {
	Run          func(context.Context) error
	Prepare      func(context.Context) (boot.Config, func() error, error)
	DefaultState string
	Command      string
	Args         []string
	Transient    bool
}

Plan is the host's decision for one launch. A non-empty DefaultState replaces the executable's default state when the invocation did not explicitly name one with --state. Command or Args replace the values the grammar selected. Run hands the whole launch to the host. Prepare opens host resources under the state lock and returns the configuration they need together with the close that releases them. Transient runs an ordinary application command in a private temporary state. It cannot accompany Run, and it is valid only for OpRun.