app

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
	Name       string
	Command    string
	Bundle     Bundle
	Components []boot.Component
}

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 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
}

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.