brick

type Manifest ¶

type Manifest struct {
	APIVersion string
	Kind       string
	Metadata   ManifestMetadata
	Spec       ManifestSpec
	// contains filtered or unexported fields
}

Manifest is /agk/brick.yaml as a value.

It is read here rather than in the evaluator because it is the brick's half of the contract and this package already is the two edges of the container. A second reader in the evaluator would be a second answer to what a manifest is, and agk brick test gets this one with no evaluator in reach.

What this type applies is the manifest's own rules: the five required keys, the closed blocks wherever the document is the engine's and the open ones wherever the author is writing JSON Schema, the name grammar, the version grammar, a secret mounted under /agk/secrets/ and a CPU request written as a string. The rules that hold a manifest and a workflow together, that a step's outputs are a subset of the ports declared here and that its params satisfy the schemas declared here, stay in the evaluator, which is where a refusal can name the step.

func ParseManifest(doc []byte) (Manifest, error)

func ParseStoredManifest(doc []byte) (Manifest, error)

func (m Manifest) CheckPortLengths() error

func (m Manifest) Document() []byte

func (m Manifest) InputPorts() []agk.Port

func (m Manifest) OutputPorts() []agk.Port

func (m Manifest) Port(name agk.Port) (ManifestPort, bool)

type ManifestMetadata ¶

type ManifestMetadata struct {
	Name    string
	Version string
	Summary string
}

ManifestMetadata is what the brick is called and which release this is.

type ManifestPort ¶

type ManifestPort struct {
	Schema json.RawMessage
}

ManifestPort is one declared port. It carries a schema and nothing else, and the schema itself is optional: "a port declared with no schema accepts whatever arrives, which is what a passthrough brick says".

Schema is the JSON Schema document as it was written, not a compiled one. Compiling it is the evaluator's business and needs a JSON Schema implementation, which this package does not carry: keeping the bytes is what lets the manifest be read anywhere.

type ManifestResources ¶

type ManifestResources struct {
	CPU    string
	Memory string
	PIDs   int
}

ManifestResources is what the brick asks for, before the runner policy and the namespace quota cap it.

type ManifestSpec ¶

type ManifestSpec struct {
	Inputs      map[agk.Port]ManifestPort
	Outputs     map[agk.Port]ManifestPort
	Params      map[string]Param
	Secrets     []Secret
	Runtime     Runtime
	Resources   ManifestResources
	Definitions map[string]json.RawMessage
}

ManifestSpec is what the brick reads, what it writes, and what it needs from its container.

type Mount ¶

type Mount struct {
	Port     agk.Port
	Source   string
	Target   string
	ReadOnly bool
}

Mount is one input directory, as the driver has to bind it.

ReadOnly is a stated field rather than something the driver is left to remember: an input a step can write to is an input a retry of that step reads differently, and the contract says the mount is read-only.

func WriteInputs(ctx context.Context, s *artifact.Store, dir string, in map[agk.Port]agk.Envelope) ([]Mount, error)

type Param ¶

type Param struct {
	Schema    json.RawMessage
	Required  bool
	Sensitive bool
}

Param is one declared parameter: a JSON Schema subschema, and the one keyword that is not JSON Schema's.

Required is required: true written on the parameter itself, saying that a step must supply it. The array form of the key keeps its JSON Schema meaning and stays in Schema, where it names the members the value must carry; only the boolean is the language's own, and it is lifted out of Schema so that what is left is a document a JSON Schema implementation will compile.

type Putter ¶ added in v0.2.0

type Putter interface {
	Put(ctx context.Context, u agk.URI, mediaType string, r io.Reader) (agk.File, error)
}

Putter is what a spilled value is written through: an *artifact.Store, or anything that answers a write with the files[] entry the store would answer.

It is an interface rather than the store itself so that a caller can hold the envelope Spill returns to the size rules before anything reaches the store. A runner refuses an envelope before its first upload, and the entries that envelope carries are the ones the store will answer, so it describes the writes here and makes them once the envelope has passed.

type Runtime ¶

type Runtime struct {
	Network   string
	User      string
	Streaming bool
}

Runtime is what the runner builds the host configuration from.

type Secret ¶

type Secret struct {
	Name     string
	Mount    string
	Optional bool
}

Secret is one secret the brick needs, by the name the workflow will answer with.