1
0
Fork 0
mirror of https://github.com/moby/moby.git synced 2022-11-09 12:21:53 -05:00
moby--moby/volume/drivers/adapter.go

177 lines
3.9 KiB
Go
Raw Normal View History

package volumedrivers // import "github.com/docker/docker/volume/drivers"
import (
"errors"
"strings"
"time"
"github.com/docker/docker/volume"
"github.com/sirupsen/logrus"
)
var (
errNoSuchVolume = errors.New("no such volume")
)
type volumeDriverAdapter struct {
name string
scopePath func(s string) string
capabilities *volume.Capability
proxy *volumeDriverProxy
}
func (a *volumeDriverAdapter) Name() string {
return a.name
}
func (a *volumeDriverAdapter) Create(name string, opts map[string]string) (volume.Volume, error) {
if err := a.proxy.Create(name, opts); err != nil {
return nil, err
}
return &volumeAdapter{
proxy: a.proxy,
name: name,
driverName: a.name,
scopePath: a.scopePath,
}, nil
}
func (a *volumeDriverAdapter) Remove(v volume.Volume) error {
return a.proxy.Remove(v.Name())
}
func (a *volumeDriverAdapter) List() ([]volume.Volume, error) {
ls, err := a.proxy.List()
if err != nil {
return nil, err
}
var out []volume.Volume
for _, vp := range ls {
out = append(out, &volumeAdapter{
proxy: a.proxy,
name: vp.Name,
scopePath: a.scopePath,
driverName: a.name,
eMount: a.scopePath(vp.Mountpoint),
})
}
return out, nil
}
func (a *volumeDriverAdapter) Get(name string) (volume.Volume, error) {
v, err := a.proxy.Get(name)
if err != nil {
return nil, err
}
// plugin may have returned no volume and no error
if v == nil {
return nil, errNoSuchVolume
}
return &volumeAdapter{
proxy: a.proxy,
name: v.Name,
driverName: a.Name(),
eMount: v.Mountpoint,
createdAt: v.CreatedAt,
status: v.Status,
scopePath: a.scopePath,
}, nil
}
func (a *volumeDriverAdapter) Scope() string {
cap := a.getCapabilities()
return cap.Scope
}
func (a *volumeDriverAdapter) getCapabilities() volume.Capability {
if a.capabilities != nil {
return *a.capabilities
}
cap, err := a.proxy.Capabilities()
if err != nil {
// `GetCapabilities` is a not a required endpoint.
// On error assume it's a local-only driver
logrus.Warnf("Volume driver %s returned an error while trying to query its capabilities, using default capabilities: %v", a.name, err)
return volume.Capability{Scope: volume.LocalScope}
}
// don't spam the warn log below just because the plugin didn't provide a scope
if len(cap.Scope) == 0 {
cap.Scope = volume.LocalScope
}
cap.Scope = strings.ToLower(cap.Scope)
if cap.Scope != volume.LocalScope && cap.Scope != volume.GlobalScope {
logrus.Warnf("Volume driver %q returned an invalid scope: %q", a.Name(), cap.Scope)
cap.Scope = volume.LocalScope
}
a.capabilities = &cap
return cap
}
type volumeAdapter struct {
proxy *volumeDriverProxy
name string
scopePath func(string) string
driverName string
eMount string // ephemeral host volume path
createdAt time.Time // time the directory was created
status map[string]interface{}
}
type proxyVolume struct {
Name string
Mountpoint string
CreatedAt time.Time
Status map[string]interface{}
}
func (a *volumeAdapter) Name() string {
return a.name
}
func (a *volumeAdapter) DriverName() string {
return a.driverName
}
func (a *volumeAdapter) Path() string {
if len(a.eMount) == 0 {
mountpoint, _ := a.proxy.Path(a.name)
a.eMount = a.scopePath(mountpoint)
}
return a.eMount
}
func (a *volumeAdapter) CachedPath() string {
return a.eMount
}
func (a *volumeAdapter) Mount(id string) (string, error) {
mountpoint, err := a.proxy.Mount(a.name, id)
a.eMount = a.scopePath(mountpoint)
return a.eMount, err
}
func (a *volumeAdapter) Unmount(id string) error {
err := a.proxy.Unmount(a.name, id)
if err == nil {
a.eMount = ""
}
return err
}
func (a *volumeAdapter) CreatedAt() (time.Time, error) {
return a.createdAt, nil
}
func (a *volumeAdapter) Status() map[string]interface{} {
out := make(map[string]interface{}, len(a.status))
for k, v := range a.status {
out[k] = v
}
return out
}