types

package
v0.1.0-rc2 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 10, 2016 License: Apache-2.0 Imports: 12 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// ConfigRoot is a config key.
	ConfigRoot = "libstorage"

	// ConfigServer is a config key.
	ConfigServer = ConfigRoot + ".server"

	// ConfigClient is a config key.
	ConfigClient = ConfigRoot + ".client"

	// ConfigHost is a config key.
	ConfigHost = ConfigRoot + ".host"

	// ConfigEmbedded is a config key.
	ConfigEmbedded = ConfigRoot + ".embedded"

	// ConfigService is a config key.
	ConfigService = ConfigRoot + ".service"

	// ConfigOSDriver is a config key.
	ConfigOSDriver = ConfigRoot + ".os.driver"

	// ConfigStorageDriver is a config key.
	ConfigStorageDriver = ConfigRoot + ".storage.driver"

	// ConfigIntegrationDriver is a config key.
	ConfigIntegrationDriver = ConfigRoot + ".integration.driver"

	// ConfigLogLevel is a config key.
	ConfigLogLevel = ConfigRoot + ".logging.level"

	// ConfigLogStdout is a config key.
	ConfigLogStdout = ConfigRoot + ".logging.stdout"

	// ConfigLogStderr is a config key.
	ConfigLogStderr = ConfigRoot + ".logging.stderr"

	// ConfigLogHTTPRequests is a config key.
	ConfigLogHTTPRequests = ConfigRoot + ".logging.httpRequests"

	// ConfigLogHTTPResponses is a config key.
	ConfigLogHTTPResponses = ConfigRoot + ".logging.httpResponses"

	// ConfigHTTPDisableKeepAlive is a config key.
	ConfigHTTPDisableKeepAlive = ConfigRoot + ".http.disableKeepAlive"

	// ConfigHTTPWriteTimeout is a config key.
	ConfigHTTPWriteTimeout = ConfigRoot + ".http.writeTimeout"

	// ConfigHTTPReadTimeout is a config key.
	ConfigHTTPReadTimeout = ConfigRoot + ".http.readTimeout"

	// ConfigServices is a config key.
	ConfigServices = ConfigServer + ".services"

	// ConfigEndpoints is a config key.
	ConfigEndpoints = ConfigServer + ".endpoints"

	// ConfigExecutorPath is a config key.
	ConfigExecutorPath = ConfigRoot + ".executor.path"

	// ConfigExecutorNoDownload is a config key.
	ConfigExecutorNoDownload = ConfigRoot + ".executor.disableDownload"

	// ConfigClientCacheInstanceID is a config key.
	ConfigClientCacheInstanceID = ConfigClient + ".cache.instanceID"

	// ConfigTLS is a config key.
	ConfigTLS = ConfigRoot + ".tls"

	// ConfigTLSDisabled is a config key.
	ConfigTLSDisabled = ConfigTLS + ".disabled"

	// ConfigTLSServerName is a config key.
	ConfigTLSServerName = ConfigTLS + ".serverName"

	// ConfigTLSClientCertRequired is a config key.
	ConfigTLSClientCertRequired = ConfigTLS + ".clientCertRequired"

	// ConfigTLSTrustedCertsFile is a config key.
	ConfigTLSTrustedCertsFile = ConfigTLS + ".trustedCertsFile"

	// ConfigTLSCertFile is a config key.
	ConfigTLSCertFile = ConfigTLS + ".certFile"

	// ConfigTLSKeyFile is a config key.
	ConfigTLSKeyFile = ConfigTLS + ".keyFile"

	// ConfigDeviceAttachTimeout is a config key.
	ConfigDeviceAttachTimeout = ConfigRoot + ".device.attachTimeout"

	// ConfigDeviceScanType is a config key.
	ConfigDeviceScanType = ConfigRoot + ".device.scanType"
)
View Source 
const (
	//ConfigIg is a config key.
	ConfigIg = ConfigRoot + ".integration"

	//ConfigIgVol is a config key.
	ConfigIgVol = ConfigIg + ".volume"

	//ConfigIgVolOps is a config key.
	ConfigIgVolOps = ConfigIgVol + ".operations"

	//ConfigIgVolOpsMount is a config key.
	ConfigIgVolOpsMount = ConfigIgVolOps + ".mount"

	//ConfigIgVolOpsMountPreempt is a config key.
	ConfigIgVolOpsMountPreempt = ConfigIgVolOpsMount + ".preempt"

	//ConfigIgVolOpsMountPath is a config key.
	ConfigIgVolOpsMountPath = ConfigIgVolOpsMount + ".path"

	//ConfigIgVolOpsMountRootPath is a config key.
	ConfigIgVolOpsMountRootPath = ConfigIgVolOpsMount + ".rootPath"

	//ConfigIgVolOpsUnmount is a config key.
	ConfigIgVolOpsUnmount = ConfigIgVolOps + ".unmount"

	//ConfigIgVolOpsUnmountIgnoreUsed is a config key.
	ConfigIgVolOpsUnmountIgnoreUsed = ConfigIgVolOpsUnmount + ".ignoreusedcount"

	// ConfigIgVolOpsPath is a config key.
	ConfigIgVolOpsPath = ConfigIgVolOps + ".path"

	// ConfigIgVolOpsPathCache is a config key.
	ConfigIgVolOpsPathCache = ConfigIgVolOpsPath + ".cache"

	// ConfigIgVolOpsCreate is a config key.
	ConfigIgVolOpsCreate = ConfigIgVolOps + ".create"

	// ConfigIgVolOpsCreateDisable is a config key.
	ConfigIgVolOpsCreateDisable = ConfigIgVolOpsCreate + ".disable"

	// ConfigIgVolOpsCreateImplicit is a config key.
	ConfigIgVolOpsCreateImplicit = ConfigIgVolOpsCreate + ".implicit"

	// ConfigIgVolOpsCreateDefault is a config key.
	ConfigIgVolOpsCreateDefault = ConfigIgVolOpsCreate + ".default"

	// ConfigIgVolOpsCreateDefaultSize is a config key.
	ConfigIgVolOpsCreateDefaultSize = ConfigIgVolOpsCreateDefault + ".size"

	// ConfigIgVolOpsCreateDefaultFsType is a config key.
	ConfigIgVolOpsCreateDefaultFsType = ConfigIgVolOpsCreateDefault + ".fsType"

	// ConfigIgVolOpsCreateDefaultAZ is a config key.
	ConfigIgVolOpsCreateDefaultAZ = ConfigIgVolOpsCreateDefault + ".availabilityZone"

	// ConfigIgVolOpsCreateDefaultType is a config key.
	ConfigIgVolOpsCreateDefaultType = ConfigIgVolOpsCreateDefault + ".type"

	// ConfigIgVolOpsCreateDefaultIOPS is a config key.
	ConfigIgVolOpsCreateDefaultIOPS = ConfigIgVolOpsCreateDefault + ".IOPS"

	// ConfigIgVolOpsRemove is a config key.
	ConfigIgVolOpsRemove = ConfigIgVolOps + ".remove"

	// ConfigIgVolOpsRemoveDisable is a config key.
	ConfigIgVolOpsRemoveDisable = ConfigIgVolOpsRemove + ".disable"
)
View Source 
const (
	//ConfigOldRoot is a config key.
	ConfigOldRoot = "volume"

	// ConfigOldIntegrationVolMountPreempt is a config key.
	ConfigOldIntegrationVolMountPreempt = ConfigOldRoot + ".mount.preempt"

	// ConfigOldIntegrationVolCreateDisable is a config key.
	ConfigOldIntegrationVolCreateDisable = ConfigOldRoot + ".create.disable"

	// ConfigOldIntegrationVolRemoveDisable is a config key.
	ConfigOldIntegrationVolRemoveDisable = ConfigOldRoot + ".remove.disable"

	// ConfigOldIntegrationVolUnmountIgnoreUsed is a config key.
	ConfigOldIntegrationVolUnmountIgnoreUsed = ConfigOldRoot + ".unmount.ignoreusedcount"

	// ConfigOldIntegrationVolPathCache is a config key.
	ConfigOldIntegrationVolPathCache = ConfigOldRoot + ".path.cache"

	//ConfigOldDocker is a config key.
	ConfigOldDocker = "docker"

	//ConfigOldDockerFsType is a config key.
	ConfigOldDockerFsType = ConfigOldDocker + ".fsType"

	//ConfigOldDockerVolumeType is a  config key.
	ConfigOldDockerVolumeType = ConfigOldDocker + ".volumeType"

	//ConfigOldDockerIOPS is a config key.
	ConfigOldDockerIOPS = ConfigOldDocker + ".iops"

	//ConfigOldDockerSize is a config key.
	ConfigOldDockerSize = ConfigOldDocker + ".size"

	//ConfigOldDockerAvailabilityZone is a config key.
	ConfigOldDockerAvailabilityZone = ConfigOldDocker + ".availabilityZone"

	//ConfigOldDockerMountDirPath is a config key.
	ConfigOldDockerMountDirPath = ConfigOldDocker + ".mountDirPath"

	//ConfigOldDockerLinuxVolumeRootPath is a config key.
	ConfigOldDockerLinuxVolumeRootPath = "linux.volume.rootpath"
)
View Source 
const (
	// InstanceIDHeader is the HTTP header that contains an InstanceID.
	InstanceIDHeader = "Libstorage-Instanceid"

	// InstanceID64Header is the HTTP header that contains a base64-encoded
	// InstanceID.
	InstanceID64Header = "Libstorage-Instanceid64"

	// LocalDevicesHeader is the HTTP header that contains a local device pair.
	LocalDevicesHeader = "Libstorage-Localdevices"

	// TransactionIDHeader is the HTTP header that contains the transaction ID
	// sent from the client.
	TransactionIDHeader = "Libstorage-Txid"

	// TransactionCreatedHeader is the HTTP header that contains the UTC
	// epoch of the time that the transaction was created.
	TransactionCreatedHeader = "Libstorage-Txcr"

	// ServerNameHeader is the HTTP header that contains the randomly generated
	// name the server creates for unique identification when the server starts
	// for the first time. This header is provided with every response sent
	// from the server.
	ServerNameHeader = "Libstorage-Servername"
)

All header names below follow the Golang canonical format for header keys. Please do not alter their casing to your liking or you will break stuff.

View Source 
const (
	// TaskStateQueued is the state for a task that has been enqueued but not
	// yet started.
	TaskStateQueued TaskState = "queued"

	// TaskStateRunning is the state for a task that is running.
	TaskStateRunning = "running"

	// TaskStateSuccess is the state for a task that has completed successfully.
	TaskStateSuccess = "success"

	// TaskStateError is the state for a task that has completed with an error.
	TaskStateError = "error"
)
View Source 
const LibStorageDriverName = "libstorage"

LibStorageDriverName is the name of the libStorage storage driver.

Variables

View Source 
var ErrNotImplemented = goof.New("not implemented")

ErrNotImplemented is the error that Driver implementations should return if a function is not implemented.

View Source 
var LSX string

LSX is the default name of the libStorage executor for the current OS.

Functions

func BackCompat 

func BackCompat(config gofig.Config)

BackCompat ensures keys can be used from old configurations.

Types

type APIClient 

type APIClient interface {

	// EnableInstanceIDHeaders is a flag indicating whether or not the
	// client will automatically send the instance ID header(s) along with
	// storage-related API requests. The default is enabled.
	EnableInstanceIDHeaders(enabled bool)

	// EnableLocalDevicesHeaders is a flag indicating whether or not the
	// client will automatically send the local devices header(s) along with
	// storage-related API requests. The default is enabled.
	EnableLocalDevicesHeaders(enabled bool)

	// 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)

	// AddHeader provides the API client with a key/value pair that are
	// added to all outgoing HTTP requests as a header.
	AddHeader(key, value string)

	// AddHeaderForDriver is a variant of AddHeader and adds a header in the
	// format HEADER_KEY: DRIVER_NAME=HEADER_VALUE_KEY=HEADER_VALUE_VALUE.
	// If there's an existing header with the same HEADER_KEY and
	// DRIVER_NAME it is replaced.
	AddHeaderForDriver(driverName, key, value string)

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

APIClient is the libStorage API client used for communicating with a remote libStorage endpoint.

type APIFunc 

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

APIFunc is an adapter to allow the use of ordinary functions as API endpoints. Any function that has the appropriate signature can be register as an API endpoint.

type Client 

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
}

Client is the libStorage client.

type ClientDriver 

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

ClientDriver is the client-side driver that is able to inspect methods before and after they are invoked in order to both prevent their execution as well as mutate the results.

type ConfigKey 

type ConfigKey string

ConfigKey is a configuration key.

type Context 

type Context interface {
	context.Context
	log.FieldLogger

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

	// Log returns the underlying logger instance.
	Log() *log.Logger

	// ServerName gets the server name.
	ServerName() string

	// TransactionID gets the transaction ID.
	TransactionID() string

	// TransactionCreated gets the timestamp of when the transaction was
	// created.
	TransactionCreated() time.Time

	// InstanceIDsByService returns the context's service to instance ID map.
	InstanceIDsByService() map[string]*InstanceID

	// InstanceID returns the context's instance ID.
	InstanceID() *InstanceID

	// LocalDevicesByService returns the context's service to local devices map.
	LocalDevicesByService() map[string]map[string]string

	// LocalDevices returns the context's local devices map.
	LocalDevices() map[string]string

	// Profile returns the context's profile name.
	Profile() string

	// Route returns the name of context's route.
	Route() string

	// ServiceName returns the name of the context's service.
	ServiceName() string

	// Client returns this context's client.
	Client() Client

	// WithHTTPRequest returns a context with the provided HTTP request.
	WithHTTPRequest(req *http.Request) Context

	// WithValue returns a context with the provided value.
	WithValue(key interface{}, val interface{}) Context

	// WithInstanceIDsByService returns a context with the provided service to
	// instance ID map.
	WithInstanceIDsByService(val map[string]*InstanceID) Context

	// WithInstanceID returns a context with the provided instance ID.
	WithInstanceID(val *InstanceID) Context

	// WithLocalDevicesByService returns a context with the provided service to
	// local devices map.
	WithLocalDevicesByService(val map[string]map[string]string) Context

	// WithLocalDevices returns a context with the provided local devices map.
	WithLocalDevices(val map[string]string) Context

	// WithProfile returns a context with the provided profile.
	WithProfile(profile string) Context

	// WithRoute returns a contex with the provided route name.
	WithRoute(routeName string) Context

	// WithServiceName returns a contex with the provided service name.
	WithServiceName(serviceName string) Context

	// WithContextID returns a context with the provided context ID information.
	// The context ID is often used with logging to identify a log statement's
	// origin.
	WithContextID(id, value string) Context

	// WithContextSID is the same as the WithContextID function except this
	// variant only accepts fmt.Stringer values for its id argument.
	WithContextSID(id fmt.Stringer, value string) Context

	// WithTransactionID returns a context with the provided transaction ID.
	WithTransactionID(transactionID string) Context

	// WithTransactionCreated returns a context with the provided transaction
	// created timestamp.
	WithTransactionCreated(timestamp time.Time) Context

	// WithClient returns a context with the provided client.
	WithClient(client Client) Context
}

Context is a libStorage context.

type ContextKey 

type ContextKey int

ContextKey is the type used as a context key. 

const (
	// ContextHTTPRequest is a context key.
	ContextHTTPRequest ContextKey = 5000 + iota

	// ContextLogger is a context key.
	ContextLogger

	// ContextInstanceID is a context key.
	ContextInstanceID

	// ContextInstanceIDsByService is a context key.
	ContextInstanceIDsByService

	// ContextProfile is a context key.
	ContextProfile

	// ContextRoute is a context key.
	ContextRoute

	// ContextContextID is a context key.
	ContextContextID

	// ContextService is a context key.
	ContextService

	// ContextServiceName is a context key.
	ContextServiceName

	// ContextDriver is a context key.
	ContextDriver

	// ContextDriverName is a context key.
	ContextDriverName

	// ContextLocalDevices is a context key.
	ContextLocalDevices

	// ContextLocalDevicesByService is a context key.
	ContextLocalDevicesByService

	// ContextServerName is a context key.
	ContextServerName

	// ContextTransactionID is a context key.
	ContextTransactionID

	// ContextTransactionCreated is a context key.
	ContextTransactionCreated

	// ContextClient is a context key.
	ContextClient

	// ContextOSDriver is a context key.
	ContextOSDriver

	// ContextStorageDriver is a context key.
	ContextStorageDriver

	// ContextIntegrationDriver is a context key.
	ContextIntegrationDriver

	// ContextUser is a context key.
	ContextUser

	// ContextHost is a context key.
	ContextHost
)

func (ContextKey) String 

func (ck ContextKey) String() string

String returns the string-representation of the context key.

type DeviceFormatOpts 

type DeviceFormatOpts struct {
	NewFSType   string
	OverwriteFS bool
	Opts        Store
}

DeviceFormatOpts are options when formatting a device.

type DeviceMountOpts 

type DeviceMountOpts struct {
	MountOptions string
	MountLabel   string
	Opts         Store
}

DeviceMountOpts are options when mounting a device.

type DeviceScanType 

type DeviceScanType int

DeviceScanType is a type of device scan algorithm. 

const (

	// DeviceScanQuick performs a shallow, quick scan.
	DeviceScanQuick DeviceScanType = iota

	// DeviceScanDeep performs a deep, longer scan.
	DeviceScanDeep
)

func ParseDeviceScanType 

func ParseDeviceScanType(i interface{}) DeviceScanType

ParseDeviceScanType parses a device scan type.

func (DeviceScanType) String 

func (st DeviceScanType) String() string

String returns the string representation of a DeviceScanType.

type Driver 

type Driver interface {

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

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

Driver is the base interface for a libStorage driver.

type DriverInfo 

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

DriverInfo is information about a driver.

type ErrBadFilter 

type ErrBadFilter struct{ goof.Goof }

ErrBadFilter occurs when a bad filter is supplied via the filter query string.

type ErrBatchProcess 

type ErrBatchProcess struct{ goof.Goof }

ErrBatchProcess occurs when a batch process is interrupted by an error before the process is complete. This error will contain information about the objects for which the process did complete.

type ErrContextKey 

type ErrContextKey struct{ goof.Goof }

ErrContextKey occurs when no value exists for a specified context key.

type ErrContextType 

type ErrContextType struct{ goof.Goof }

ErrContextType occurs when a value exists in the context but is not the expected typed.

type ErrDriverTypeErr 

type ErrDriverTypeErr struct{ goof.Goof }

ErrDriverTypeErr occurs when a Driver is constructed with an invalid type.

type ErrMissingInstanceID 

type ErrMissingInstanceID struct{ goof.Goof }

ErrMissingInstanceID occurs when an operation requires the instance ID for the configured service to be avaialble.

type ErrNotFound 

type ErrNotFound struct{ goof.Goof }

ErrNotFound occurs when a Driver inspects or sends an operation to a resource that cannot be found.

type ErrStoreKey 

type ErrStoreKey struct{ goof.Goof }

ErrStoreKey occurs when no value exists for a specified store key.

type ExecutorInfo 

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"`

	// 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"`
}

ExecutorInfo contains information about a client-side executor, such as its name and MD5 checksum.

type ExecutorsMap 

type ExecutorsMap map[string]*ExecutorInfo

ExecutorsMap is the response when getting one to many ExecutorInfos.

type Filter 

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
}

Filter is an LDAP-style filter string.

type FilterOperator 

type FilterOperator int

FilterOperator is a filter operator. 

const (
	// FilterAnd is the & operator.
	FilterAnd FilterOperator = iota

	// FilterOr is the | operator.
	FilterOr

	// FilterNot is the ! operator.
	FilterNot

	// FilterPresent is the =* operator.
	FilterPresent

	// FilterEqualityMatch is the = operator.
	FilterEqualityMatch

	// FilterSubstrings is the = operator in conjunction with a string that
	// has leading and trailing * characters.
	FilterSubstrings

	// FilterSubstringsPrefix is the = operator in conjunction with a string
	// that has a leading * character.
	FilterSubstringsPrefix

	// FilterSubstringsPostfix is the = operator in conjunction with a string
	// that has a trailing * character.
	FilterSubstringsPostfix

	// FilterGreaterOrEqual is the >= operator.
	FilterGreaterOrEqual

	// FilterLessOrEqual is the <= operator.
	FilterLessOrEqual

	// FilterApproxMatch is the ~= operator.
	FilterApproxMatch
)

type Instance 

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

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

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

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

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

Instance provides information about a storage object.

type InstanceID 

type InstanceID struct {
	// ID is the instance ID
	ID string `json:"id"`

	// Formatted is a flag indicating whether or not the instance ID has
	// been formatted by an instance inspection.
	Formatted bool `json:"formatted,omitempty"`

	// Metadata is any extra information about the instance ID.
	Metadata json.RawMessage `json:"metadata,omitempty"`
}

InstanceID identifies a host to a remote storage platform.

type IntegrationDriver 

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
}

IntegrationDriver is the interface implemented to integrate external storage consumers, such as Docker, with libStorage.

type IntegrationDriverManager 

type IntegrationDriverManager interface {
	IntegrationDriver

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

IntegrationDriverManager is the management wrapper for an IntegrationDriver.

type LocalDevicesOpts 

type LocalDevicesOpts struct {
	ScanType DeviceScanType
	Opts     Store
}

LocalDevicesOpts are options when getting a list of local devices.

type Middleware 

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
}

Middleware is middleware for a route.

type MiddlewareFunc 

type MiddlewareFunc func(handler APIFunc) APIFunc

MiddlewareFunc is an adapter to allow the use of ordinary functions as API filters. Any function that has the appropriate signature can be register as a middleware.

type MountInfo 

type MountInfo struct {
	// ID is a unique identifier of the mount (may be reused after umount).
	ID int `json:"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"`

	// 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"`

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

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

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

MountInfo reveals information about a particular mounted filesystem. This struct is populated from the content in the /proc/<pid>/mountinfo file.

type NewClientDriver 

type NewClientDriver func() ClientDriver

NewClientDriver is a function that constructs a new ClientDriver.

type NewIntegrationDriver 

type NewIntegrationDriver func() IntegrationDriver

NewIntegrationDriver is a function that constructs a new IntegrationDriver.

type NewOSDriver 

type NewOSDriver func() OSDriver

NewOSDriver is a function that constructs a new OSDriver.

type NewRequestObjFunc 

type NewRequestObjFunc func() interface{}

NewRequestObjFunc is a function that creates a new instance of the type to which the request body is serialized.

type NewRouteFunc 

type NewRouteFunc func(config gofig.Config) Route

NewRouteFunc returns a new route.

type NewStorageDriver 

type NewStorageDriver func() StorageDriver

NewStorageDriver is a function that constructs a new StorageDriver.

type NewStorageExecutor 

type NewStorageExecutor func() StorageExecutor

NewStorageExecutor is a function that constructs a new StorageExecutors.

type NextDeviceInfo 

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

NextDeviceInfo assists the libStorage client in determining the next available device name by providing the driver's device prefix and optional pattern.

For example, the Amazon Web Services (AWS) device prefix is "xvd" and its pattern is "[a-z]". These two values would be used to determine on an EC2 instance where "/dev/xvda" and "/dev/xvdb" are in use that the next available device name is "/dev/xvdc".

If the Ignore field is set to true then the client logic does not invoke the GetNextAvailableDeviceName function prior to submitting an AttachVolume request to the server.

type OSDriver 

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
}

OSDriver is the interface implemented by types that provide OS introspection and management.

type OSDriverManager 

type OSDriverManager interface {
	OSDriver

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

OSDriverManager is the management wrapper for an OSDriver.

type ProvidesAPIClient 

type ProvidesAPIClient interface {

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

ProvidesAPIClient is any type that provides the API client.

type ProvidesStorageExecutorCLI 

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

ProvidesStorageExecutorCLI is a type that provides the StorageExecutorCLI.

type Route 

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
}

Route defines an individual API route in the server.

type Router 

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

Router defines an interface to specify a group of routes to add the the server.

type Service 

type Service interface {
	Driver
}

Service is the base type for services.

type ServiceInfo 

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

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

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

ServiceInfo is information about a service.

type ServiceSnapshotMap 

type ServiceSnapshotMap map[string]SnapshotMap

ServiceSnapshotMap is the response for listing snapshots for multiple services.

type ServiceVolumeMap 

type ServiceVolumeMap map[string]VolumeMap

ServiceVolumeMap is the response for listing volumes for multiple services.

type Services 

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

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

Services is a service's container.

type ServicesMap 

type ServicesMap map[string]*ServiceInfo

ServicesMap is the response when getting one to many ServiceInfos.

type Snapshot 

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

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

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

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

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

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

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

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

Snapshot provides information about a storage-layer snapshot.

type SnapshotCopyRequest 

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

SnapshotCopyRequest is the JSON body for copying a snapshot.

type SnapshotMap 

type SnapshotMap map[string]*Snapshot

SnapshotMap is the response for listing snapshots for a single service.

type SnapshotRemoveRequest 

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

SnapshotRemoveRequest is the JSON body for removing a snapshot.

type StorageDriver 

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
}

StorageDriver is a libStorage driver used by the routes to implement the backend functionality.

Functions that inspect a resource or send an operation to a resource should always return ErrResourceNotFound if the acted upon resource cannot be found.

type StorageDriverManager 

type StorageDriverManager interface {
	StorageDriver

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

StorageDriverManager is the management wrapper for a StorageDriver.

type StorageExecutor 

type StorageExecutor interface {
	Driver
	StorageExecutorFunctions
}

StorageExecutor is the part of a storage driver that is downloaded at runtime by the libStorage client.

type StorageExecutorCLI 

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, map[string]string, error)
}

StorageExecutorCLI provides a way to interact with the CLI tool built with the driver implementations of the StorageExecutor interface.

type StorageExecutorFunctions 

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) (map[string]string, error)
}

StorageExecutorFunctions is the collection of functions that are required of a StorageExecutor.

type StorageService 

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
}

StorageService is a service that provides the interaction with StorageDrivers.

type StorageTaskRunFunc 

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

StorageTaskRunFunc is a function responsible for a storage-service task's execution.

type StorageType 

type StorageType string

StorageType is the type of storage a driver provides. 

const (
	// Block is block storage.
	Block StorageType = "block"

	// NAS is network attached storage.
	NAS StorageType = "nas"

	// Object is object-backed storage.
	Object StorageType = "object"
)

type Store 

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

Store is a key/value store with case-insensitive keys.

type Task 

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

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

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

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

	// StartTime is the time stamp when the task started running.
	StartTime int64 `json:"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"`

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

Task is a representation of an asynchronous, long-running task.

type TaskExecutionService 

type TaskExecutionService interface {
	Service

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

TaskExecutionService is a service for executing tasks.

type TaskRunFunc 

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

TaskRunFunc is a function responsible for a task's execution.

type TaskState 

type TaskState string

TaskState is the possible state of a task.

type TaskTrackingService 

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
}

TaskTrackingService a service for tracking tasks.

type Volume 

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

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

	// The volume IOPs.
	IOPS int64 `json:"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"`

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

	// The volume status.
	Status string `json:"status,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"`

	// 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"`
}

Volume provides information about a storage volume.

func (*Volume) MountPoint 

func (v *Volume) MountPoint() string

MountPoint returns the volume's mount point, if one is present.

func (*Volume) VolumeName 

func (v *Volume) VolumeName() string

VolumeName returns the volume's name.

type VolumeAttachOpts 

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

VolumeAttachOpts are options for attaching a volume.

type VolumeAttachRequest 

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

VolumeAttachRequest is the JSON body for attaching a volume to an instance.

type VolumeAttachResponse 

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

VolumeAttachResponse is the JSON response for attaching a volume to an instance.

type VolumeAttachment 

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

	// 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"`

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

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

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

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

VolumeAttachment provides information about an object attached to a storage volume.

type VolumeCopyRequest 

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

VolumeCopyRequest is the JSON body for copying a volume.

type VolumeCreateOpts 

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

VolumeCreateOpts are options when creating a new volume.

type VolumeCreateRequest 

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

VolumeCreateRequest is the JSON body for creating a new volume.

type VolumeDetachOpts 

type VolumeDetachOpts struct {
	Force bool
	Opts  Store
}

VolumeDetachOpts are options for detaching a volume.

type VolumeDetachRequest 

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

VolumeDetachRequest is the JSON body for detaching a volume from an instance.

type VolumeDevice 

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"`

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

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

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

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

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

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

VolumeDevice provides information about a volume's backing storage device. This might be a block device, NAS device, object device, etc.

type VolumeInspectOpts 

type VolumeInspectOpts struct {
	Attachments bool
	Opts        Store
}

VolumeInspectOpts are options when inspecting a volume.

type VolumeMap 

type VolumeMap map[string]*Volume

VolumeMap is the response for listing volumes for a single service.

type VolumeMapping 

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

VolumeMapping is a volume's name and the path to which it is mounted.

type VolumeMountOpts 

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

VolumeMountOpts are options for mounting a volume.

type VolumeSnapshotRequest 

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

VolumeSnapshotRequest is the JSON body for snapshotting a volume.

type VolumesOpts 

type VolumesOpts struct {
	Attachments bool
	Opts        Store
}

VolumesOpts are options when inspecting a volume.

type WaitForDeviceOpts 

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
}

WaitForDeviceOpts are options when waiting on specific local device to appear.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.