core

type Descriptor ¶

type Descriptor struct {
	Kind     string   `json:"kind"`
	Pipeline string   `json:"pipeline"`
	Metadata Metadata `json:"metadata"`
}

Descriptor is a type which describes a Phase

func (d Descriptor) String() string

type Edge ¶

type Edge interface {
	Kind() string
	From() Descriptor
	To() Descriptor
	Perform(context.Context) (*Result, error)
	CanPerform(context.Context) (bool, error)
}

Edge represents an edge between two phases. Edges have have their own kind which identifies their Perform behaviour.

type EdgeOptions ¶

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

type Metadata ¶

type Metadata struct {
	Name        string            `json:"name"`
	Labels      map[string]string `json:"labels,omitempty"`
	Annotations map[string]string `json:"annotations,omitempty"`
}

Metadata contains the unique information used to identify a named resource instance in a particular phase.

type Phase ¶

type Phase interface {
	Descriptor() Descriptor
	Get(context.Context) (Resource, error)
	History(context.Context) ([]State, error)
}

Phase is the core interface for resource sourcing and management. These types can be registered on pipelines and can depend upon on another for promotion.

type PhaseOptions ¶

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

PhaseOptions scopes a call to get phases from a pipeline.

func (p *PhaseOptions) Matches(phase Phase) bool

type Pipeline ¶

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

Pipeline is a collection of phases for a given resource type R. It implements the core.Phase interface and is scoped to a single Resource implementation.

func NewPipeline(meta Metadata) *Pipeline

func (p *Pipeline) AddEdge(e Edge) error

func (p *Pipeline) AddPhase(phase Phase) error

func (p *Pipeline) Edges(o ...containers.Option[EdgeOptions]) iter.Seq[Edge]

func (p *Pipeline) EdgesFrom() map[string]map[string]Edge

func (p *Pipeline) Metadata() Metadata

func (p *Pipeline) PhaseByName(name string) (Phase, error)

func (p *Pipeline) Phases(opts ...containers.Option[PhaseOptions]) iter.Seq[Phase]

type Resource ¶

type Resource interface {
	Digest() (string, error)
}

Resource is an instance of a resource in a phase. Primarilly, it exposes a Digest method used to produce a hash digest of the resource instances current state.

type ResourceWithAnnotations ¶

type ResourceWithAnnotations interface {
	Resource
	Annotations() map[string]string
}

ResourceWithAnnotations is a resource with additional annotations

type Result ¶

type Result struct {
	Annotations map[string]string `json:"annotations"`
}

Result is a type that carries annotations relating to the result of calling Perform on an edge.

type RollbackPhase ¶

type RollbackPhase interface {
	Phase
	// Rollback performs a rollback operation to a previous state identified
	// by a version uuid.
	Rollback(context.Context, uuid.UUID) (*Result, error)
}

RollbackPhase is a phase which can be rolled back to a previous version.

type State ¶

type State struct {
	Version     uuid.UUID         `json:"version,omitempty"`
	Resource    Resource          `json:"resource,omitempty"`
	Digest      string            `json:"digest,omitempty"`
	Annotations map[string]string `json:"annotations,omitempty"`
	RecordedAt  time.Time         `json:"recorded_at,omitempty"`
}

State contains a snapshot of a resource version at a point in history

type TriggerableEdge ¶

type TriggerableEdge interface {
	Edge
	RunTriggers(context.Context) error
}

TriggerableEdge is an edge that has an additional method RunTriggers. This method should schedule any necessary dependencies needed to automate calling perform on the respectibe edge (e.g. start background schedules).