driver

Documentation

Index

• Constants
• type Configurable
• type DebugDriver
  • func (d *DebugDriver) Config() map[string]string
  • func (d *DebugDriver) Handles(dt string) bool
  • func (d *DebugDriver) Run(op *Operation) (OperationResult, error)
  • func (d *DebugDriver) SetConfig(settings map[string]string)
• type Driver
• type Operation
• type OperationResult
• type ResolvedCred

Constants

const (
	ImageTypeDocker = "docker"
	ImageTypeOCI    = "oci"
	ImageTypeQCOW   = "qcow"
)

ImageType constants provide some of the image types supported TODO: I think we can remove all but Docker, since the rest are supported externally

Types

type Configurable

type Configurable interface {
	// Config returns a map of configuration names and values that can be set via environment variable
	Config() map[string]string
	// SetConfig allows setting configuration, where name corresponds to the key in Config, and value is
	// the value to be set.
	SetConfig(map[string]string)
}

Configurable drivers can explain their configuration, and have it explicitly set

type DebugDriver

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

DebugDriver prints the information passed to a driver

It does not ever run the image.

func (*DebugDriver) Config

func (d *DebugDriver) Config() map[string]string

Config returns the configuration help text

func (*DebugDriver) Handles

func (d *DebugDriver) Handles(dt string) bool

Handles always returns true, effectively claiming to work for any image type

func (*DebugDriver) Run

func (d *DebugDriver) Run(op *Operation) (OperationResult, error)

Run executes the operation on the Debug driver

func (*DebugDriver) SetConfig

func (d *DebugDriver) SetConfig(settings map[string]string)

SetConfig sets configuration for this driver

type Driver

type Driver interface {
	// Run executes the operation inside of the invocation image
	Run(*Operation) (OperationResult, error)
	// Handles receives an ImageType* and answers whether this driver supports that type
	Handles(string) bool
}

Driver is capable of running a invocation image

type Operation

type Operation struct {
	// Installation is the name of this installation
	Installation string `json:"installation_name"`
	// The revision ID for this installation
	Revision string `json:"revision"`
	// Action is the action to be performed
	Action string `json:"action"`
	// Parameters are the parameters to be injected into the container
	Parameters map[string]interface{} `json:"parameters"`
	// Image is the invocation image
	Image bundle.InvocationImage `json:"image"`
	// Environment contains environment variables that should be injected into the invocation image
	Environment map[string]string `json:"environment"`
	// Files contains files that should be injected into the invocation image.
	Files map[string]string `json:"files"`
	// Outputs is a list of paths starting with `/cnab/app/outputs` that the driver should return the contents of in the OperationResult.
	Outputs []string `json:"outputs"`
	// Output stream for log messages from the driver
	Out io.Writer `json:"-"`
	// Bundle represents the bundle information for use by the operation
	Bundle *bundle.Bundle
}

Operation describes the data passed into the driver to run an operation

type OperationResult

type OperationResult struct {
	// Outputs is a map from the container path of an output file to its contents (i.e. /cnab/app/outputs/...).
	Outputs map[string]string
}

OperationResult is the output of the Driver running an Operation.

type ResolvedCred

type ResolvedCred struct {
	Type  string `json:"type"`
	Name  string `json:"name"`
	Value string `json:"value"`
}

ResolvedCred is a credential that has been resolved and is ready for injection into the runtime.