types

type APIClient interface {

	// ServerName returns the name of the server to which the client is
	// connected. This is not the same as the host name, rather it's the
	// randomly generated name the server creates for unique identification
	// when the server starts for the first time.
	ServerName() string

	// LogRequests enables or disables the logging of client HTTP requests.
	LogRequests(enabled bool)

	// LogResponses enables or disables the logging of client HTTP responses.
	LogResponses(enabled bool)

	// Root returns a list of root resources.
	Root(ctx Context) ([]string, error)

	// Instances returns a list of instances.
	Instances(ctx Context) (map[string]*Instance, error)

	// InstanceInspect inspects an instance.
	InstanceInspect(ctx Context, service string) (*Instance, error)

	// Services returns a map of the configured Services.
	Services(ctx Context) (map[string]*ServiceInfo, error)

	// ServiceInspect returns information about a service.
	ServiceInspect(ctx Context, name string) (*ServiceInfo, error)

	// Volumes returns a list of all Volumes for all Services.
	Volumes(
		ctx Context,
		attachments bool) (ServiceVolumeMap, error)

	// VolumesByService returns a list of all Volumes for a service.
	VolumesByService(
		ctx Context,
		service string,
		attachments bool) (VolumeMap, error)

	// VolumeInspect gets information about a single volume.
	VolumeInspect(
		ctx Context,
		service, volumeID string,
		attachments bool) (*Volume, error)

	// VolumeCreate creates a single volume.
	VolumeCreate(
		ctx Context,
		service string,
		request *VolumeCreateRequest) (*Volume, error)

	// VolumeCreateFromSnapshot creates a single volume from a snapshot.
	VolumeCreateFromSnapshot(
		ctx Context,
		service, snapshotID string,
		request *VolumeCreateRequest) (*Volume, error)

	// VolumeCopy copies a single volume.
	VolumeCopy(
		ctx Context,
		service, volumeID string,
		request *VolumeCopyRequest) (*Volume, error)

	// VolumeRemove removes a single volume.
	VolumeRemove(
		ctx Context,
		service, volumeID string) error

	// VolumeAttach attaches a single volume.
	VolumeAttach(
		ctx Context,
		service string,
		volumeID string,
		request *VolumeAttachRequest) (*Volume, string, error)

	// VolumeDetach attaches a single volume.
	VolumeDetach(
		ctx Context,
		service string,
		volumeID string,
		request *VolumeDetachRequest) (*Volume, error)

	// VolumeDetachAll attaches all volumes from all
	VolumeDetachAll(
		ctx Context,
		request *VolumeDetachRequest) (ServiceVolumeMap, error)

	// VolumeDetachAllForService detaches all volumes from a service.
	VolumeDetachAllForService(
		ctx Context,
		service string,
		request *VolumeDetachRequest) (VolumeMap, error)

	// VolumeSnapshot creates a single snapshot.
	VolumeSnapshot(
		ctx Context,
		service string,
		volumeID string,
		request *VolumeSnapshotRequest) (*Snapshot, error)

	// Snapshots returns a list of all Snapshots for all
	Snapshots(ctx Context) (ServiceSnapshotMap, error)

	// SnapshotsByService returns a list of all Snapshots for a single service.
	SnapshotsByService(
		ctx Context, service string) (SnapshotMap, error)

	// SnapshotInspect gets information about a single snapshot.
	SnapshotInspect(
		ctx Context,
		service, snapshotID string) (*Snapshot, error)

	// SnapshotRemove removes a single snapshot.
	SnapshotRemove(
		ctx Context,
		service, snapshotID string) error

	// SnapshotCopy copies a snapshot to a new snapshot.
	SnapshotCopy(
		ctx Context,
		service, snapshotID string,
		request *SnapshotCopyRequest) (*Snapshot, error)

	// Executors returns information about the executors.
	Executors(
		ctx Context) (map[string]*ExecutorInfo, error)

	// ExecutorHead returns information about an executor.
	ExecutorHead(
		ctx Context,
		name string) (*ExecutorInfo, error)

	// ExecutorGet downloads an executor.
	ExecutorGet(
		ctx Context, name string) (io.ReadCloser, error)
}

type APIFunc func(
	ctx Context,
	w http.ResponseWriter,
	r *http.Request,
	store Store) error

type Client interface {

	// API returns the underlying libStorage API client.
	API() APIClient

	// OS returns the client's OS driver instance.
	OS() OSDriver

	// Storage returns the client's storage driver instance.
	Storage() StorageDriver

	// IntegrationDriver returns the client's integration driver instance.
	Integration() IntegrationDriver

	// Executor returns the storage executor CLI.
	Executor() StorageExecutorCLI
}

type ClientDriver interface {
	Driver

	// InstanceInspectBefore may return an error, preventing the operation.
	InstanceInspectBefore(ctx *Context) error

	// InstanceInspectAfter provides an opportunity to inspect/mutate the
	// result.
	InstanceInspectAfter(ctx Context, result *Instance)

	// VolumesBefore may return an error, preventing the operation.
	VolumesBefore(ctx *Context) error

	// VolumesAfter provides an opportunity to inspect/mutate the result.
	VolumesAfter(ctx Context, result *ServiceVolumeMap)

	// VolumesByServiceBefore may return an error, preventing the operation.
	VolumesByServiceBefore(ctx *Context, service string) error

	// VolumesByServiceAfter provides an opportunity to inspect/mutate the
	// result.
	VolumesByServiceAfter(
		ctx Context, service string, result *VolumeMap)

	// VolumeInspectBefore may return an error, preventing the operation.
	VolumeInspectBefore(
		ctx *Context, service, volumeID string, attachments bool) error

	// VolumeInspectAfter provides an opportunity to inspect/mutate the result.
	VolumeInspectAfter(ctx Context, result *Volume)

	// VolumeCreateBefore may return an error, preventing the operation.
	VolumeCreateBefore(
		ctx *Context, service string,
		request *VolumeCreateRequest) error

	// VolumeCreateAfter provides an opportunity to inspect/mutate the result.
	VolumeCreateAfter(ctx Context, result *Volume)

	// VolumeCreateFromSnapshotBefore may return an error, preventing the
	// operation.
	VolumeCreateFromSnapshotBefore(
		ctx *Context,
		service, snapshotID string,
		request *VolumeCreateRequest) error

	// VolumeCreateFromSnapshotAfter provides an opportunity to inspect/mutate
	// the result.
	VolumeCreateFromSnapshotAfter(ctx Context, result *Volume)

	// VolumeCopyBefore may return an error, preventing the operation.
	VolumeCopyBefore(
		ctx *Context,
		service, volumeID string,
		request *VolumeCopyRequest) error

	// VolumeCopyAfter provides an opportunity to inspect/mutate the result.
	VolumeCopyAfter(ctx Context, result *Volume)

	// VolumeRemoveBefore may return an error, preventing the operation.
	VolumeRemoveBefore(
		ctx *Context,
		service, volumeID string) error

	// VolumeRemoveAfter provides an opportunity to inspect/mutate the result.
	VolumeRemoveAfter(ctx Context, service, volumeID string)

	// VolumeSnapshotBefore may return an error, preventing the operation.
	VolumeSnapshotBefore(
		ctx *Context,
		service, volumeID string,
		request *VolumeSnapshotRequest) error

	// VolumeSnapshotAfter provides an opportunity to inspect/mutate the result.
	VolumeSnapshotAfter(ctx Context, result *Snapshot)

	// VolumeAttachBefore may return an error, preventing the operation.
	VolumeAttachBefore(
		ctx *Context,
		service, volumeID string,
		request *VolumeAttachRequest) error

	// VolumeAttachAfter provides an opportunity to inspect/mutate the result.
	VolumeAttachAfter(ctx Context, result *Volume)

	// VolumeDetachBefore may return an error, preventing the operation.
	VolumeDetachBefore(
		ctx *Context,
		service, volumeID string,
		request *VolumeDetachRequest) error

	// VolumeDetachAfter provides an opportunity to inspect/mutate the result.
	VolumeDetachAfter(ctx Context, result *Volume)

	// SnapshotsBefore may return an error, preventing the operation.
	SnapshotsBefore(ctx *Context) error

	// SnapshotsAfter provides an opportunity to inspect/mutate the result.
	SnapshotsAfter(ctx Context, result *ServiceSnapshotMap)

	// SnapshotsByServiceBefore may return an error, preventing the operation.
	SnapshotsByServiceBefore(ctx *Context, service string) error

	// SnapshotsByServiceAfter provides an opportunity to inspect/mutate the
	// result.
	SnapshotsByServiceAfter(
		ctx Context, service string, result *SnapshotMap)

	// SnapshotInspectBefore may return an error, preventing the operation.
	SnapshotInspectBefore(
		ctx *Context,
		service, snapshotID string) error

	// SnapshotInspectAfter provides an opportunity to inspect/mutate the
	// result.
	SnapshotInspectAfter(ctx Context, result *Volume)

	// SnapshotCopyBefore may return an error, preventing the operation.
	SnapshotCopyBefore(
		ctx *Context,
		service, snapshotID, string,
		request *SnapshotCopyRequest) error

	// SnapshotCopyAfter provides an opportunity to inspect/mutate the result.
	SnapshotCopyAfter(ctx Context, result *Snapshot)

	// SnapshotRemoveBefore may return an error, preventing the operation.
	SnapshotRemoveBefore(ctx *Context, service, snapshotID string) error

	// SnapshotRemoveAfter provides an opportunity to inspect/mutate the result.
	SnapshotRemoveAfter(ctx Context, snapshotID string)
}

type ClientType int

type ConfigKey string

type Context interface {
	context.Context
	FieldLogger

	// WithValue returns a copy of parent in which the value associated with
	// key is val.
	WithValue(key, value interface{}) Context

	// Join joins this context with another, such that value lookups will first
	// first check the current context, and if no such value exist, a lookup
	// will be performed against the right side.
	Join(ctx context.Context) Context
}

type ContextLoggerFieldAware interface {

	// ContextLoggerField is the fields that is logged as part of a Context's
	// log entry.
	ContextLoggerField() (string, interface{})
}

type ContextLoggerFieldsAware interface {

	// ContextLoggerFields are the fields that are logged as part of a
	// Context's log entry.
	ContextLoggerFields() map[string]interface{}
}

type DeviceFormatOpts struct {
	NewFSType   string
	OverwriteFS bool
	Opts        Store
}

type DeviceMountOpts struct {
	MountOptions string
	MountLabel   string
	Opts         Store
}

type DeviceScanType int

type Driver interface {

	// Name returns the name of the driver
	Name() string

	// Init initializes the driver.
	Init(ctx Context, config gofig.Config) error
}

type DriverInfo struct {
	// Name is the driver's name.
	Name string `json:"name"`

	// Type is the type of storage the driver provides: block, nas, object.
	Type StorageType `json:"type"`

	// NextDevice is the next available device information for the service.
	NextDevice *NextDeviceInfo `json:"nextDevice,omitempty" yaml:"nextDevice,omitempty"`
}

type EndpointType int

type ErrBadAdminToken struct{ goof.Goof }

type ErrBadFilter struct{ goof.Goof }

type ErrBatchProcess struct{ goof.Goof }

type ErrContextKey struct{ goof.Goof }

type ErrContextType struct{ goof.Goof }

type ErrDriverTypeErr struct{ goof.Goof }

type ErrMissingInstanceID struct{ goof.Goof }

type ErrNotFound struct{ goof.Goof }

type ErrStoreKey struct{ goof.Goof }

type ErrUnsupportedForClientType struct{ goof.Goof }

type ExecutorInfo struct {

	// Name is the name of the executor.
	Name string `json:"name"`

	// MD5Checksum is the MD5 checksum of the executor. This can be used to
	// determine if a local copy of the executor needs to be updated.
	MD5Checksum string `json:"md5checksum" yaml:"md5checksum"`

	// Size is the size of the executor in bytes.
	Size int64 `json:"size"`

	// LastModified is the time the executor was last modified as an epoch.
	LastModified int64 `json:"lastModified" yaml:"lastModified"`
}

type ExecutorsMap map[string]*ExecutorInfo

type FieldLogger interface {
	WithField(key string, value interface{}) LogEntry
	WithFields(fields logrus.Fields) LogEntry
	WithError(err error) LogEntry

	Debugf(format string, args ...interface{})
	Infof(format string, args ...interface{})
	Printf(format string, args ...interface{})
	Warnf(format string, args ...interface{})
	Warningf(format string, args ...interface{})
	Errorf(format string, args ...interface{})
	Fatalf(format string, args ...interface{})
	Panicf(format string, args ...interface{})

	Debug(args ...interface{})
	Info(args ...interface{})
	Print(args ...interface{})
	Warn(args ...interface{})
	Warning(args ...interface{})
	Error(args ...interface{})
	Fatal(args ...interface{})
	Panic(args ...interface{})

	Debugln(args ...interface{})
	Infoln(args ...interface{})
	Println(args ...interface{})
	Warnln(args ...interface{})
	Warningln(args ...interface{})
	Errorln(args ...interface{})
	Fatalln(args ...interface{})
	Panicln(args ...interface{})
}

type Filter struct {

	// Op is the operation.
	Op FilterOperator

	// Children is a list of any sub-filters if this filter is a compound
	// filter.
	Children []*Filter

	// Left is the left operand.
	Left string

	// Right is the right operand.
	Right string
}

type FilterOperator int

type Instance struct {
	// The ID of the instance to which the object is connected.
	InstanceID *InstanceID `json:"instanceID" yaml:"instanceID,omitempty"`

	// The name of the instance.
	Name string `json:"name,omitempty" yaml:",omitempty"`

	// The name of the provider that owns the object.
	ProviderName string `json:"providerName" yaml:"providerName,omitempty"`

	// The region from which the object originates.
	Region string `json:"region,omitempty" yaml:",omitempty"`

	// Fields are additional properties that can be defined for this type.
	Fields map[string]string `json:"fields,omitempty" yaml:",omitempty"`
}

type InstanceID struct {

	// ID is the simple part of the InstanceID.
	ID string `json:"id" yaml:"id"`

	// Driver is the name of the StorageExecutor that created the InstanceID
	// as well as the name of the StorageDriver for which the InstanceID is
	// valid.
	Driver string `json:"driver"`
	// contains filtered or unexported fields
}

type InstanceIDMap map[string]*InstanceID

type IntegrationDriver interface {
	Driver

	// List a map that relates volume names to their mount points.
	List(
		ctx Context,
		opts Store) ([]VolumeMapping, error)

	// Inspect returns a specific volume as identified by the provided
	// volume name.
	Inspect(
		ctx Context,
		volumeName string,
		opts Store) (VolumeMapping, error)

	// Mount will return a mount point path when specifying either a volumeName
	// or volumeID.  If a overwriteFs boolean is specified it will overwrite
	// the FS based on newFsType if it is detected that there is no FS present.
	Mount(
		ctx Context,
		volumeID, volumeName string,
		opts *VolumeMountOpts) (string, *Volume, error)

	// Unmount will unmount the specified volume by volumeName or volumeID.
	Unmount(
		ctx Context,
		volumeID, volumeName string,
		opts Store) error

	// Path will return the mounted path of the volumeName or volumeID.
	Path(
		ctx Context,
		volumeID, volumeName string,
		opts Store) (string, error)

	// Create will create a new volume with the volumeName and opts.
	Create(
		ctx Context,
		volumeName string,
		opts *VolumeCreateOpts) (*Volume, error)

	// Remove will remove a volume of volumeName.
	Remove(
		ctx Context,
		volumeName string,
		opts Store) error

	// Attach will attach a volume based on volumeName to the instance of
	// instanceID.
	Attach(
		ctx Context,
		volumeName string,
		opts *VolumeAttachOpts) (string, error)

	// Detach will detach a volume based on volumeName to the instance of
	// instanceID.
	Detach(
		ctx Context,
		volumeName string,
		opts *VolumeDetachOpts) error
}

type IntegrationDriverManager interface {
	IntegrationDriver

	// Driver returns the underlying driver.
	Driver() IntegrationDriver
}

type Level log.Level

type LocalDevices struct {

	// Driver is the name of the StorageExecutor that created the map
	// as well as the name of the StorageDriver for which the map is
	// valid.
	Driver string `json:"driver"`

	// DeviceMap is voluem to device mappings.
	DeviceMap map[string]string `json:"deviceMap,omitempty" yaml:"deviceMap,omitempty"`
}

type LocalDevicesMap map[string]*LocalDevices

type LocalDevicesOpts struct {
	ScanType DeviceScanType
	Opts     Store
}

type LogEntry interface {
	FieldLogger
}

type Middleware interface {

	// Name returns the name of the middlware.
	Name() string

	// Handler enables the chaining of middlware.
	Handler(handler APIFunc) APIFunc

	// Handle is for processing an incoming request.
	Handle(
		ctx Context,
		w http.ResponseWriter,
		r *http.Request,
		store Store) error
}

type MiddlewareFunc func(handler APIFunc) APIFunc

type MountInfo struct {
	// ID is a unique identifier of the mount (may be reused after umount).
	ID int `json:"id" yaml:"id"`

	// Parent indicates the ID of the mount parent (or of self for the top of
	// the mount tree).
	Parent int `json:"parent"`

	// Major indicates one half of the device ID which identifies the device
	// class.
	Major int `json:"major"`

	// Minor indicates one half of the device ID which identifies a specific
	// instance of device.
	Minor int `json:"minor"`

	// Root of the mount within the filesystem.
	Root string `json:"root"`

	// MountPoint indicates the mount point relative to the process's root.
	MountPoint string `json:"mountPoint" yaml:"mountPoint"`

	// Opts represents mount-specific options.
	Opts string `json:"opts"`

	// Optional represents optional fields.
	Optional string `json:"optional"`

	// FSType indicates the type of filesystem, such as EXT3.
	FSType string `json:"fsType" yaml:"fsType"`

	// Source indicates filesystem specific information or "none".
	Source string `json:"source"`

	// VFSOpts represents per super block options.
	VFSOpts string `json:"vfsOpts" yaml:"vfsOpts"`

	// Fields are additional properties that can be defined for this type.
	Fields map[string]string `json:"fields,omitempty" yaml:",omitempty"`
}

type NewClientDriver func() ClientDriver

type NewIntegrationDriver func() IntegrationDriver

type NewOSDriver func() OSDriver

type NewRequestObjFunc func() interface{}

type NewStorageDriver func() StorageDriver

type NewStorageExecutor func() StorageExecutor

type NextDeviceInfo struct {
	// Ignore is a flag that indicates whether the client logic should invoke
	// the GetNextAvailableDeviceName function prior to submitting an
	// AttachVolume request to the server.
	Ignore bool `json:"ignore"`

	// Prefix is the first part of a device path's value after the "/dev/"
	// porition. For example, the prefix in "/dev/xvda" is "xvd".
	Prefix string `json:"prefix"`

	// Pattern is the regex to match the part of a device path after the prefix.
	Pattern string `json:"pattern"`
}

type OSDriver interface {
	Driver

	// Mounts get a list of mount points for a local device.
	Mounts(
		ctx Context,
		deviceName, mountPoint string,
		opts Store) ([]*MountInfo, error)

	// Mount mounts a device to a specified path.
	Mount(
		ctx Context,
		deviceName, mountPoint string,
		opts *DeviceMountOpts) error

	// Unmount unmounts the underlying device from the specified path.
	Unmount(
		ctx Context,
		mountPoint string,
		opts Store) error

	// IsMounted checks whether a path is mounted or not
	IsMounted(
		ctx Context,
		mountPoint string,
		opts Store) (bool, error)

	// Format formats a device.
	Format(
		ctx Context,
		deviceName string,
		opts *DeviceFormatOpts) error
}

type OSDriverManager interface {
	OSDriver

	// Driver returns the underlying driver.
	Driver() OSDriver
}

type ProvidesAPIClient interface {

	// API provides the API client.
	API() APIClient
}

type ProvidesStorageExecutorCLI interface {
	// XCLI returns the StorageExecutorCLI.
	XCLI() StorageExecutorCLI
}

type Route interface {

	// Queries add query strings that must match for a route.
	Queries(queries ...string) Route

	// Middlewares adds middleware to the route.
	Middlewares(middlewares ...Middleware) Route

	// Name returns the name of the route.
	GetName() string

	// GetHandler returns the raw function to create the http handler.
	GetHandler() APIFunc

	// GetMethod returns the http method that the route responds to.
	GetMethod() string

	// GetPath returns the subpath where the route responds to.
	GetPath() string

	// GetQueries returns the query strings for which the route should respond.
	GetQueries() []string

	// GetMiddlewares returns a list of route-specific middleware.
	GetMiddlewares() []Middleware
}

type Router interface {

	// Routes returns all of the router's routes.
	Routes() []Route

	// Name returns the name of the router.
	Name() string

	// Init initializes the router.
	Init(config gofig.Config)
}

type Server interface {
	io.Closer

	// Name returns the name of the server.
	Name() string

	// Addrs returns the server's configured endpoint addresses.
	Addrs() []string
}

type Service interface {
	Driver
}

type ServiceInfo struct {
	// Name is the service's name.
	Name string `json:"name"`

	// Instance is the service's instance.
	Instance *Instance `json:"instance,omitempty" yaml:",omitempty"`

	// Driver is the name of the driver registered for the service.
	Driver *DriverInfo `json:"driver"`
}

type ServiceSnapshotMap map[string]SnapshotMap

type ServiceVolumeMap map[string]VolumeMap

type Services interface {
	// Storage gets the storage service.
	Storage() StorageService

	// Tasks gets the task service.
	Tasks() TaskTrackingService
}

type ServicesMap map[string]*ServiceInfo

type Snapshot struct {
	// A description of the snapshot.
	Description string `json:"description,omitempty" yaml:",omitempty"`

	// The name of the snapshot.
	Name string `json:"name,omitempty" yaml:",omitempty"`

	// The snapshot's ID.
	ID string `json:"id" yaml:"id"`

	// The time (epoch) at which the request to create the snapshot was submitted.
	StartTime int64 `json:"startTime,omitempty" yaml:"startTime,omitempty"`

	// The status of the snapshot.
	Status string `json:"status,omitempty" yaml:",omitempty"`

	// The ID of the volume to which the snapshot belongs.
	VolumeID string `json:"volumeID,omitempty" yaml:"volumeID,omitempty"`

	// The size of the volume to which the snapshot belongs.
	VolumeSize int64 `json:"volumeSize,omitempty" yaml:"volumeSize,omitempty"`

	// Fields are additional properties that can be defined for this type.
	Fields map[string]string `json:"fields,omitempty" yaml:",omitempty"`
}

type SnapshotCopyRequest struct {
	SnapshotName  string                 `json:"snapshotName"`
	DestinationID string                 `json:"destinationID"`
	Opts          map[string]interface{} `json:"opts,omitempty"`
}

type SnapshotMap map[string]*Snapshot

type SnapshotRemoveRequest struct {
	Opts map[string]interface{} `json:"opts,omitempty"`
}

type StorageDriver interface {
	Driver

	// NextDeviceInfo returns the information about the driver's next available
	// device workflow.
	NextDeviceInfo(
		ctx Context) (*NextDeviceInfo, error)

	// Type returns the type of storage the driver provides.
	Type(
		ctx Context) (StorageType, error)

	// InstanceInspect returns an instance.
	InstanceInspect(
		ctx Context,
		opts Store) (*Instance, error)

	// Volumes returns all volumes or a filtered list of volumes.
	Volumes(
		ctx Context,
		opts *VolumesOpts) ([]*Volume, error)

	// VolumeInspect inspects a single volume.
	VolumeInspect(
		ctx Context,
		volumeID string,
		opts *VolumeInspectOpts) (*Volume, error)

	// VolumeCreate creates a new volume.
	VolumeCreate(
		ctx Context,
		name string,
		opts *VolumeCreateOpts) (*Volume, error)

	// VolumeCreateFromSnapshot creates a new volume from an existing snapshot.
	VolumeCreateFromSnapshot(
		ctx Context,
		snapshotID,
		volumeName string,
		opts *VolumeCreateOpts) (*Volume, error)

	// VolumeCopy copies an existing volume.
	VolumeCopy(
		ctx Context,
		volumeID,
		volumeName string,
		opts Store) (*Volume, error)

	// VolumeSnapshot snapshots a volume.
	VolumeSnapshot(
		ctx Context,
		volumeID,
		snapshotName string,
		opts Store) (*Snapshot, error)

	// VolumeRemove removes a volume.
	VolumeRemove(
		ctx Context,
		volumeID string,
		opts Store) error

	// VolumeAttach attaches a volume and provides a token clients can use
	// to validate that device has appeared locally.
	VolumeAttach(
		ctx Context,
		volumeID string,
		opts *VolumeAttachOpts) (*Volume, string, error)

	// VolumeDetach detaches a volume.
	VolumeDetach(
		ctx Context,
		volumeID string,
		opts *VolumeDetachOpts) (*Volume, error)

	// Snapshots returns all volumes or a filtered list of snapshots.
	Snapshots(
		ctx Context,
		opts Store) ([]*Snapshot, error)

	// SnapshotInspect inspects a single snapshot.
	SnapshotInspect(
		ctx Context,
		snapshotID string,
		opts Store) (*Snapshot, error)

	// SnapshotCopy copies an existing snapshot.
	SnapshotCopy(
		ctx Context,
		snapshotID,
		snapshotName,
		destinationID string,
		opts Store) (*Snapshot, error)

	// SnapshotRemove removes a snapshot.
	SnapshotRemove(
		ctx Context,
		snapshotID string,
		opts Store) error
}

type StorageDriverManager interface {
	StorageDriver

	// Driver returns the underlying driver.
	Driver() StorageDriver
}

type StorageExecutor interface {
	Driver
	StorageExecutorFunctions
}

type StorageExecutorCLI interface {
	StorageExecutorFunctions

	// WaitForDevice blocks until the provided attach token appears in the
	// map returned from LocalDevices or until the timeout expires, whichever
	// occurs first.
	//
	// The return value is a boolean flag indicating whether or not a match was
	// discovered as well as the result of the last LocalDevices call before a
	// match is discovered or the timeout expires.
	WaitForDevice(
		ctx Context,
		opts *WaitForDeviceOpts) (bool, *LocalDevices, error)
}

type StorageExecutorFunctions interface {
	// InstanceID returns the local system's InstanceID.
	InstanceID(
		ctx Context,
		opts Store) (*InstanceID, error)

	// NextDevice returns the next available device.
	NextDevice(
		ctx Context,
		opts Store) (string, error)

	// LocalDevices returns a map of the system's local devices.
	LocalDevices(
		ctx Context,
		opts *LocalDevicesOpts) (*LocalDevices, error)
}

type StorageService interface {
	Service

	// Driver returns the service's StorageDriver.
	Driver() StorageDriver

	// TaskExecute enqueues a task for execution.
	TaskExecute(
		ctx Context,
		run StorageTaskRunFunc,
		schema []byte) *Task
}

type StorageTaskRunFunc func(
	ctx Context,
	service StorageService) (interface{}, error)

type StorageType string

type Store interface {

	// Map returns the contents of the store as a map[string]interface{}.
	Map() map[string]interface{}

	// Keys returns a list of all the keys in the store.
	Keys() []string

	// IsSet returns true if a key exists.
	IsSet(k string) bool

	// Get returns a value for the key; a nil value if the key does not exist.
	Get(k string) interface{}

	// GetString returns a string value for a key; an empty string if the key
	// does not exist.
	GetString(k string) string

	// GetStringPtr returns a pointer to a string value for a key; nil if
	// the key does not exist.
	GetStringPtr(k string) *string

	// GetBool returns a boolean value for the key; false if the key does not
	// exist.
	GetBool(k string) bool

	// GetBoolPtr returns a pointer to a boolean value for the key; nil if the
	// key does not exist.
	GetBoolPtr(k string) *bool

	// GetInt return an int value for the key; 0 if the key does not exist.
	GetInt(k string) int

	// GetInt return a pointer to an int value for the key; nil if the key does
	// not exist.
	GetIntPtr(k string) *int

	// GetInt64 return an int64 value for the key; 0 if the key does not exist.
	GetInt64(k string) int64

	// GetInt64Ptr return a pointer to an int64 value for the key; nil if the
	// key does not exist.
	GetInt64Ptr(k string) *int64

	// GetIntSlice returns an int slice value for a key; a nil value if
	// the key does not exist.
	GetIntSlice(k string) []int

	// GetStringSlice returns a string slice value for a key; a nil value if
	// the key does not exist.
	GetStringSlice(k string) []string

	// GetBoolSlice returns a bool slice value for a key; a nil value if
	// the key does not exist.
	GetBoolSlice(k string) []bool

	// GetInstanceID returns an instance ID for a key; a nil value if the key
	// does not exist.
	GetInstanceID(k string) *InstanceID

	// GetMap returns a map value for a key; a nil value if the key does not
	// exist.
	GetMap(k string) map[string]interface{}

	// GetStore returns a Store value for a key; a nil value if the key does
	// not exist.
	GetStore(k string) Store

	// Set sets a key/value in the store.
	Set(k string, v interface{})

	// Deletes a key/value from the store. If the value exists in the map it
	// is returned.
	Delete(k string) interface{}
}

type Task struct {
	// ID is the task's ID.
	ID int `json:"id" yaml:"id"`

	// User is the name of the user that created the task.
	User string `json:"user,omitempty" yaml:",omitempty"`

	// CompleteTime is the time stamp when the task was completed
	// (whether success or failure).
	CompleteTime int64 `json:"completeTime,omitempty" yaml:"completeTime,omitempty"`

	// QueueTime is the time stamp when the task was created.
	QueueTime int64 `json:"queueTime" yaml:"queueTime"`

	// StartTime is the time stamp when the task started running.
	StartTime int64 `json:"startTime,omitempty" yaml:"startTime,omitempty"`

	// State is the current state of the task.
	State TaskState `json:"state"`

	// Result holds the result of the task.
	Result interface{} `json:"result,omitempty" yaml:",omitempty"`

	// Error contains the error if the task was unsuccessful.
	Error error `json:"error,omitempty" yaml:",omitempty"`
}

type TaskExecutionService interface {
	Service

	// TaskExecute enqueues a task for execution.
	TaskExecute(
		ctx Context,
		run TaskRunFunc,
		schema []byte) *Task
}

type TaskRunFunc func(ctx Context) (interface{}, error)

type TaskState string

type TaskTrackingService interface {
	Service

	// Tasks returns a channel on which all tasks tracked via TrackTasks are
	// received.
	Tasks() <-chan *Task

	// TaskTrack creates a new, trackable task.
	TaskTrack(ctx Context) *Task

	// TaskExecute enqueues a task for execution.
	TaskExecute(
		ctx Context,
		run TaskRunFunc,
		schema []byte) *Task

	// TaskInspect returns the task with the specified ID.
	TaskInspect(taskID int) *Task

	// TaskWait blocks until the specified task completes.
	TaskWait(taskID int) <-chan int

	// TaskWaitAll blocks until all the specified tasks complete.
	TaskWaitAll(taskIDs ...int) <-chan int

	// TaskWaitC returns a channel that is closed when the specified task
	// completes.
	TaskWaitC(taskID int) <-chan int

	// TaskWaitAll returns a channel that is closed when the specified task
	// completes.
	TaskWaitAllC(taskIDs ...int) <-chan int
}

type Transaction struct {

	// ID is the transaction's ID.
	ID *UUID `json:"id" yaml:"id"`

	// Created is the UTC timestampe at which the transaction was created.
	Created TxTimestamp `json:"created"`
}

type TxTimestamp time.Time

type UUID [16]byte

type VersionInfo struct {

	// SemVer is the semantic version string
	SemVer string

	// ShaLong is the commit hash from which this package was built
	ShaLong string

	// BuildTimestamp is the UTC timestamp for when this package was built.
	BuildTimestamp time.Time

	// Branch is the branch name from which this package was built
	Branch string

	// Arch is the OS-Arch string of the system on which this package is
	// supported.
	Arch string
}

type Volume struct {
	// The volume's attachments.
	Attachments []*VolumeAttachment `json:"attachments,omitempty" yaml:",omitempty"`

	// The availability zone for which the volume is available.
	AvailabilityZone string `json:"availabilityZone,omitempty" yaml:"availabilityZone,omitempty"`

	// The volume IOPs.
	IOPS int64 `json:"iops,omitempty" yaml:"iops,omitempty"`

	// The name of the volume.
	Name string `json:"name"`

	// NetworkName is the name the device is known by in order to discover
	// locally.
	NetworkName string `json:"networkName,omitempty" yaml:"networkName,omitempty"`

	// The size of the volume.
	Size int64 `json:"size,omitempty" yaml:",omitempty"`

	// The volume status.
	Status string `json:"status,omitempty" yaml:",omitempty"`

	// ID is a piece of information that uniquely identifies the volume on
	// the storage platform to which the volume belongs. A volume ID is not
	// guaranteed to be unique across multiple, configured services.
	ID string `json:"id" yaml:"id"`

	// The volume type.
	Type string `json:"type"`

	// Fields are additional properties that can be defined for this type.
	Fields map[string]string `json:"fields,omitempty" yaml:",omitempty"`
}

type VolumeAttachOpts struct {
	NextDevice *string
	Force      bool
	Opts       Store
}

type VolumeAttachRequest struct {
	Force          bool                   `json:"force,omitempty"`
	NextDeviceName *string                `json:"nextDeviceName,omitempty"`
	Opts           map[string]interface{} `json:"opts,omitempty"`
}

type VolumeAttachResponse struct {
	Volume      *Volume `json:"volume"`
	AttachToken string  `json:"attachToken"`
}

type VolumeAttachment struct {
	// The name of the device on which the volume to which the object is
	// attached is mounted.
	DeviceName string `json:"deviceName" yaml:"deviceName,omitempty"`

	// MountPoint is the mount point for the volume. This field is set when a
	// volume is retrieved via an integration driver.
	MountPoint string `json:"mountPoint,omitempty" yaml:"mountPoint,omitempty"`

	// The ID of the instance on which the volume to which the attachment
	// belongs is mounted.
	InstanceID *InstanceID `json:"instanceID" yaml:"instanceID,omitempty"`

	// The status of the attachment.
	Status string `json:"status" yaml:",omitempty"`

	// The ID of the volume to which the attachment belongs.
	VolumeID string `json:"volumeID" yaml:"volumeID,omitempty"`

	// Fields are additional properties that can be defined for this type.
	Fields map[string]string `json:"fields,omitempty" yaml:",omitempty"`
}

type VolumeCopyRequest struct {
	VolumeName string                 `json:"volumeName"`
	Opts       map[string]interface{} `json:"opts,omitempty"`
}

type VolumeCreateOpts struct {
	AvailabilityZone *string
	IOPS             *int64
	Size             *int64
	Type             *string
	Opts             Store
}

type VolumeCreateRequest struct {
	Name             string                 `json:"name"`
	AvailabilityZone *string                `json:"availabilityZone,omitempty"`
	IOPS             *int64                 `json:"iops,omitempty"`
	Size             *int64                 `json:"size,omitempty"`
	Type             *string                `json:"type,omitempty"`
	Opts             map[string]interface{} `json:"opts,omitempty"`
}

type VolumeDetachOpts struct {
	Force bool
	Opts  Store
}

type VolumeDetachRequest struct {
	Force bool                   `json:"force,omitempty"`
	Opts  map[string]interface{} `json:"opts,omitempty"`
}

type VolumeDevice struct {
	// The name of the device.
	Name string `json:"name"`

	// The ID of the instance to which the device is connected.
	InstanceID *InstanceID `json:"instanceID,omitempty" yaml:"instanceID,omitempty"`

	// The name of the network on which the device resides.
	NetworkName string `json:"networkName,omitempty" yaml:"networkName,omitempty"`

	// The name of the provider that owns the block device.
	ProviderName string `json:"providerName,omitempty" yaml:"providerName,omitempty"`

	// The region from which the device originates.
	Region string `json:"region,omitempty" yaml:",omitempty"`

	// The device status.
	Status string `json:"status"`

	// The ID of the volume for which the device is mounted.
	VolumeID string `json:"volumeID" yaml:"volumeID"`

	// Fields are additional properties that can be defined for this type.
	Fields map[string]string `json:"fields,omitempty" yaml:",omitempty"`
}

type VolumeInspectOpts struct {
	Attachments bool
	Opts        Store
}

type VolumeMap map[string]*Volume

type VolumeMapping interface {
	// VolumeName returns the volume's name.
	VolumeName() string

	// MountPoint returns the volume's mount point.
	MountPoint() string

	// Status returns the volume's details for an inspect.
	Status() map[string]interface{}
}

type VolumeMountOpts struct {
	OverwriteFS bool
	NewFSType   string
	Preempt     bool
	Opts        Store
}

type VolumeSnapshotRequest struct {
	SnapshotName string                 `json:"snapshotName"`
	Opts         map[string]interface{} `json:"opts,omitempty"`
}

type VolumesOpts struct {
	Attachments bool
	Opts        Store
}

type WaitForDeviceOpts struct {
	LocalDevicesOpts

	// Token is the value returned by a remote VolumeAttach call that the
	// client can use to block until a specific device has appeared in the
	// local devices list.
	Token string

	// Timeout is the maximum duration for which to wait for a device to
	// appear in the local devices list.
	Timeout time.Duration
}