Merge pull request #26 from vieux/move_1.8

bump to go1.8, use vndr and update vendor

Author: vieux

.travis.yml

@@ -5,10 +5,10 @@
   matrix:
     include:
       - language: go
-        go: 1.6.x
+        go: 1.7.x
         env: TESTFILE=unit.sh
       - language: go
-        go: 1.7.x
+        go: 1.8.x
         env: TESTFILE=unit.sh
       - language: go
         go: master

Dockerfile.dev

@@ -1,4 +1,4 @@
-FROM golang:1.7-alpine
+FROM golang:1.8-alpine
 
 COPY . /go/src/github.com/vieux/docker-volume-sshfs
 WORKDIR /go/src/github.com/vieux/docker-volume-sshfs

main.go

@@ -74,7 +74,7 @@ func (d *sshfsDriver) saveState() {
 	}
 }
 
-func (d *sshfsDriver) Create(r volume.Request) volume.Response {
+func (d *sshfsDriver) Create(r *volume.CreateRequest) error {
 	logrus.WithField("method", "create").Debugf("%#v", r)
 
 	d.Lock()
@@ -92,131 +92,131 @@ func (d *sshfsDriver) Create(r volume.Request) volume.Response {
 		case "allow_other":
 			v.AllowOther = true
 		default:
-			return responseError(fmt.Sprintf("unknown option %q=%q", key, val))
+			return logError("unknown option %q=%q", key, val)
 		}
 	}
 
 	if v.Sshcmd == "" {
-		return responseError("'sshcmd' option required")
+		return logError("'sshcmd' option required")
 	}
 	v.Mountpoint = filepath.Join(d.root, fmt.Sprintf("%x", md5.Sum([]byte(v.Sshcmd))))
 
 	d.volumes[r.Name] = v
 
 	d.saveState()
 
-	return volume.Response{}
+	return nil
 }
 
-func (d *sshfsDriver) Remove(r volume.Request) volume.Response {
+func (d *sshfsDriver) Remove(r *volume.RemoveRequest) error {
 	logrus.WithField("method", "remove").Debugf("%#v", r)
 
 	d.Lock()
 	defer d.Unlock()
 
 	v, ok := d.volumes[r.Name]
 	if !ok {
-		return responseError(fmt.Sprintf("volume %s not found", r.Name))
+		return logError("volume %s not found", r.Name)
 	}
 
 	if v.connections != 0 {
-		return responseError(fmt.Sprintf("volume %s is currently used by a container", r.Name))
+		return logError("volume %s is currently used by a container", r.Name)
 	}
 	if err := os.RemoveAll(v.Mountpoint); err != nil {
-		return responseError(err.Error())
+		return logError(err.Error())
 	}
 	delete(d.volumes, r.Name)
 	d.saveState()
-	return volume.Response{}
+	return nil
 }
 
-func (d *sshfsDriver) Path(r volume.Request) volume.Response {
+func (d *sshfsDriver) Path(r *volume.PathRequest) (*volume.PathResponse, error) {
 	logrus.WithField("method", "path").Debugf("%#v", r)
 
 	d.RLock()
 	defer d.RUnlock()
 
 	v, ok := d.volumes[r.Name]
 	if !ok {
-		return responseError(fmt.Sprintf("volume %s not found", r.Name))
+		return &volume.PathResponse{}, logError("volume %s not found", r.Name)
 	}
 
-	return volume.Response{Mountpoint: v.Mountpoint}
+	return &volume.PathResponse{Mountpoint: v.Mountpoint}, nil
 }
 
-func (d *sshfsDriver) Mount(r volume.MountRequest) volume.Response {
+func (d *sshfsDriver) Mount(r *volume.MountRequest) (*volume.MountResponse, error) {
 	logrus.WithField("method", "mount").Debugf("%#v", r)
 
 	d.Lock()
 	defer d.Unlock()
 
 	v, ok := d.volumes[r.Name]
 	if !ok {
-		return responseError(fmt.Sprintf("volume %s not found", r.Name))
+		return &volume.MountResponse{}, logError("volume %s not found", r.Name)
 	}
 
 	if v.connections == 0 {
 		fi, err := os.Lstat(v.Mountpoint)
 		if os.IsNotExist(err) {
 			if err := os.MkdirAll(v.Mountpoint, 0755); err != nil {
-				return responseError(err.Error())
+				return &volume.MountResponse{}, logError(err.Error())
 			}
 		} else if err != nil {
-			return responseError(err.Error())
+			return &volume.MountResponse{}, logError(err.Error())
 		}
 
 		if fi != nil && !fi.IsDir() {
-			return responseError(fmt.Sprintf("%v already exist and it's not a directory", v.Mountpoint))
+			return &volume.MountResponse{}, logError("%v already exist and it's not a directory", v.Mountpoint)
 		}
 
 		if err := d.mountVolume(v); err != nil {
-			return responseError(err.Error())
+			return &volume.MountResponse{}, logError(err.Error())
 		}
 	}
 
 	v.connections++
 
-	return volume.Response{Mountpoint: v.Mountpoint}
+	return &volume.MountResponse{Mountpoint: v.Mountpoint}, nil
 }
 
-func (d *sshfsDriver) Unmount(r volume.UnmountRequest) volume.Response {
+func (d *sshfsDriver) Unmount(r *volume.UnmountRequest) error {
 	logrus.WithField("method", "unmount").Debugf("%#v", r)
 
 	d.Lock()
 	defer d.Unlock()
 	v, ok := d.volumes[r.Name]
 	if !ok {
-		return responseError(fmt.Sprintf("volume %s not found", r.Name))
+		return logError("volume %s not found", r.Name)
 	}
 
 	v.connections--
 
 	if v.connections <= 0 {
 		if err := d.unmountVolume(v.Mountpoint); err != nil {
-			return responseError(err.Error())
+			return logError(err.Error())
 		}
 		v.connections = 0
 	}
 
-	return volume.Response{}
+	return nil
 }
 
-func (d *sshfsDriver) Get(r volume.Request) volume.Response {
+func (d *sshfsDriver) Get(r *volume.GetRequest) (*volume.GetResponse, error) {
 	logrus.WithField("method", "get").Debugf("%#v", r)
 
 	d.Lock()
 	defer d.Unlock()
 
 	v, ok := d.volumes[r.Name]
 	if !ok {
-		return responseError(fmt.Sprintf("volume %s not found", r.Name))
+		return &volume.GetResponse{}, logError("volume %s not found", r.Name)
 	}
 
-	return volume.Response{Volume: &volume.Volume{Name: r.Name, Mountpoint: v.Mountpoint}}
+	return &volume.GetResponse{Volume: &volume.Volume{Name: r.Name, Mountpoint: v.Mountpoint}}, nil
 }
 
-func (d *sshfsDriver) List(r volume.Request) volume.Response {
-	logrus.WithField("method", "list").Debugf("%#v", r)
+func (d *sshfsDriver) List() (*volume.ListResponse, error) {
+	logrus.WithField("method", "list").Debugf("")
 
 	d.Lock()
 	defer d.Unlock()
@@ -225,13 +225,13 @@ func (d *sshfsDriver) List(r volume.Request) volume.Response {
 	for name, v := range d.volumes {
 		vols = append(vols, &volume.Volume{Name: name, Mountpoint: v.Mountpoint})
 	}
-	return volume.Response{Volumes: vols}
+	return &volume.ListResponse{Volumes: vols}, nil
 }
 
-func (d *sshfsDriver) Capabilities(r volume.Request) volume.Response {
-	logrus.WithField("method", "capabilities").Debugf("%#v", r)
+func (d *sshfsDriver) Capabilities() *volume.CapabilitiesResponse {
+	logrus.WithField("method", "capabilities").Debugf("")
 
-	return volume.Response{Capabilities: volume.Capability{Scope: "local"}}
+	return &volume.CapabilitiesResponse{Capabilities: volume.Capability{Scope: "local"}}
 }
 
 func (d *sshfsDriver) mountVolume(v *sshfsVolume) error {
@@ -256,9 +256,9 @@ func (d *sshfsDriver) unmountVolume(target string) error {
 	return exec.Command("sh", "-c", cmd).Run()
 }
 
-func responseError(err string) volume.Response {
-	logrus.Error(err)
-	return volume.Response{Err: err}
+func logError(format string, args ...interface{}) error {
+	logrus.Errorf(format, args...)
+	return fmt.Errorf(format, args)
 }
 
 func main() {

vendor.conf

@@ -0,0 +1,8 @@
+github.com/Sirupsen/logrus 181d419aa9e2223811b824e8f0b4af96f9ba9302
+github.com/docker/go-plugins-helpers a9ef19c479cb60e751efa55f7f2b265776af1abf
+github.com/Microsoft/go-winio 78439966b38d69bf38227fbf57ac8a6fee70f69a
+github.com/coreos/go-systemd d2196463941895ee908e13531a23a39feb9e1243
+github.com/docker/go-connections 3ede32e2033de7505e6500d6c868c2b9ed9f169d
+golang.org/x/net 1c05540f6879653db88113bc4a2b70aec4bd491f
+golang.org/x/sys 9f7170bcd8e9f4d3691c06401119c46a769a1e03
+golang.org/x/crypto b176d7def5d71bdd214203491f89843ed217f420