Add glide.yaml and vendor deps

vendor/k8s.io/kubernetes/pkg/volume/flexvolume/BUILD

@@ -0,0 +1,45 @@
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_binary",
+    "go_library",
+    "go_test",
+    "cgo_library",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "flexvolume.go",
+        "flexvolume_util.go",
+    ],
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api/v1:go_default_library",
+        "//pkg/types:go_default_library",
+        "//pkg/util/exec:go_default_library",
+        "//pkg/util/mount:go_default_library",
+        "//pkg/util/strings:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//vendor:github.com/golang/glog",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["flexvolume_test.go"],
+    library = "go_default_library",
+    tags = ["automanaged"],
+    deps = [
+        "//pkg/api/v1:go_default_library",
+        "//pkg/types:go_default_library",
+        "//pkg/util/exec:go_default_library",
+        "//pkg/util/mount:go_default_library",
+        "//pkg/util/testing:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/testing:go_default_library",
+    ],
+)

vendor/k8s.io/kubernetes/pkg/volume/flexvolume/OWNERS

@@ -0,0 +1,2 @@
+maintainers:
+- nelcy

vendor/k8s.io/kubernetes/pkg/volume/flexvolume/flexvolume.go

@@ -0,0 +1,432 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package flexvolume
+
+import (
+	"encoding/base64"
+	"fmt"
+	"io/ioutil"
+	"os"
+	"path"
+	"strings"
+
+	"github.com/golang/glog"
+	"k8s.io/kubernetes/pkg/api/v1"
+	"k8s.io/kubernetes/pkg/types"
+	"k8s.io/kubernetes/pkg/util/exec"
+	"k8s.io/kubernetes/pkg/util/mount"
+	utilstrings "k8s.io/kubernetes/pkg/util/strings"
+	"k8s.io/kubernetes/pkg/volume"
+)
+
+// This is the primary entrypoint for volume plugins.
+func ProbeVolumePlugins(pluginDir string) []volume.VolumePlugin {
+	plugins := []volume.VolumePlugin{}
+
+	files, _ := ioutil.ReadDir(pluginDir)
+	for _, f := range files {
+		// only directories are counted as plugins
+		// and pluginDir/dirname/dirname should be an executable
+		// unless dirname contains '~' for escaping namespace
+		// e.g. dirname = vendor~cifs
+		// then, executable will be pluginDir/dirname/cifs
+		if f.IsDir() {
+			execPath := path.Join(pluginDir, f.Name())
+			plugins = append(plugins, &flexVolumePlugin{driverName: utilstrings.UnescapePluginName(f.Name()), execPath: execPath})
+		}
+	}
+	return plugins
+}
+
+// FlexVolumePlugin object.
+type flexVolumePlugin struct {
+	driverName string
+	execPath   string
+	host       volume.VolumeHost
+}
+
+// Init initializes the plugin.
+func (plugin *flexVolumePlugin) Init(host volume.VolumeHost) error {
+	plugin.host = host
+	// call the init script
+	u := &flexVolumeUtil{}
+	return u.init(plugin)
+}
+
+func (plugin *flexVolumePlugin) getExecutable() string {
+	parts := strings.Split(plugin.driverName, "/")
+	execName := parts[len(parts)-1]
+	return path.Join(plugin.execPath, execName)
+}
+
+func (plugin *flexVolumePlugin) GetPluginName() string {
+	return plugin.driverName
+}
+
+func (plugin *flexVolumePlugin) GetVolumeName(spec *volume.Spec) (string, error) {
+	volumeSource, _, err := getVolumeSource(spec)
+	if err != nil {
+		return "", err
+	}
+
+	return volumeSource.Driver, nil
+}
+
+// CanSupport checks whether the plugin can support the input volume spec.
+func (plugin *flexVolumePlugin) CanSupport(spec *volume.Spec) bool {
+	source, _, _ := getVolumeSource(spec)
+	return (source != nil) && (source.Driver == plugin.driverName)
+}
+
+func (plugin *flexVolumePlugin) RequiresRemount() bool {
+	return false
+}
+
+// GetAccessModes gets the allowed access modes for this plugin.
+func (plugin *flexVolumePlugin) GetAccessModes() []v1.PersistentVolumeAccessMode {
+	return []v1.PersistentVolumeAccessMode{
+		v1.ReadWriteOnce,
+		v1.ReadOnlyMany,
+	}
+}
+
+// NewMounter is the mounter routine to build the volume.
+func (plugin *flexVolumePlugin) NewMounter(spec *volume.Spec, pod *v1.Pod, _ volume.VolumeOptions) (volume.Mounter, error) {
+	fv, _, err := getVolumeSource(spec)
+	if err != nil {
+		return nil, err
+	}
+	secrets := make(map[string]string)
+	if fv.SecretRef != nil {
+		kubeClient := plugin.host.GetKubeClient()
+		if kubeClient == nil {
+			return nil, fmt.Errorf("Cannot get kube client")
+		}
+
+		secretName, err := kubeClient.Core().Secrets(pod.Namespace).Get(fv.SecretRef.Name)
+		if err != nil {
+			err = fmt.Errorf("Couldn't get secret %v/%v err: %v", pod.Namespace, fv.SecretRef, err)
+			return nil, err
+		}
+		for name, data := range secretName.Data {
+			secrets[name] = base64.StdEncoding.EncodeToString(data)
+			glog.V(1).Infof("found flex volume secret info: %s", name)
+		}
+	}
+	return plugin.newMounterInternal(spec, pod, &flexVolumeUtil{}, plugin.host.GetMounter(), exec.New(), secrets)
+}
+
+// newMounterInternal is the internal mounter routine to build the volume.
+func (plugin *flexVolumePlugin) newMounterInternal(spec *volume.Spec, pod *v1.Pod, manager flexVolumeManager, mounter mount.Interface, runner exec.Interface, secrets map[string]string) (volume.Mounter, error) {
+	source, _, err := getVolumeSource(spec)
+	if err != nil {
+		return nil, err
+	}
+
+	return &flexVolumeMounter{
+		flexVolumeDisk: &flexVolumeDisk{
+			podUID:       pod.UID,
+			podNamespace: pod.Namespace,
+			podName:      pod.Name,
+			volName:      spec.Name(),
+			driverName:   source.Driver,
+			execPath:     plugin.getExecutable(),
+			mounter:      mounter,
+			plugin:       plugin,
+			secrets:      secrets,
+		},
+		fsType:             source.FSType,
+		readOnly:           source.ReadOnly,
+		options:            source.Options,
+		runner:             runner,
+		manager:            manager,
+		blockDeviceMounter: &mount.SafeFormatAndMount{Interface: mounter, Runner: runner},
+	}, nil
+}
+
+// NewUnmounter is the unmounter routine to clean the volume.
+func (plugin *flexVolumePlugin) NewUnmounter(volName string, podUID types.UID) (volume.Unmounter, error) {
+	return plugin.newUnmounterInternal(volName, podUID, &flexVolumeUtil{}, plugin.host.GetMounter(), exec.New())
+}
+
+// newUnmounterInternal is the internal unmounter routine to clean the volume.
+func (plugin *flexVolumePlugin) newUnmounterInternal(volName string, podUID types.UID, manager flexVolumeManager, mounter mount.Interface, runner exec.Interface) (volume.Unmounter, error) {
+	return &flexVolumeUnmounter{
+		flexVolumeDisk: &flexVolumeDisk{
+			podUID:     podUID,
+			volName:    volName,
+			driverName: plugin.driverName,
+			execPath:   plugin.getExecutable(),
+			mounter:    mounter,
+			plugin:     plugin,
+		},
+		runner:  runner,
+		manager: manager,
+	}, nil
+}
+
+func (plugin *flexVolumePlugin) ConstructVolumeSpec(volumeName, sourceName string) (*volume.Spec, error) {
+	flexVolume := &v1.Volume{
+		Name: volumeName,
+		VolumeSource: v1.VolumeSource{
+			FlexVolume: &v1.FlexVolumeSource{
+				Driver: sourceName,
+			},
+		},
+	}
+	return volume.NewSpecFromVolume(flexVolume), nil
+}
+
+// flexVolume is the disk resource provided by this plugin.
+type flexVolumeDisk struct {
+	// podUID is the UID of the pod.
+	podUID types.UID
+	// podNamespace is the namespace of the pod.
+	podNamespace string
+	// podName is the name of the pod.
+	podName string
+	// volName is the name of the pod volume.
+	volName string
+	// driverName is the name of the plugin driverName.
+	driverName string
+	// Driver executable used to setup the volume.
+	execPath string
+	// mounter provides the interface that is used to mount the actual
+	// block device.
+	mounter mount.Interface
+	// secret for the volume.
+	secrets map[string]string
+	plugin  *flexVolumePlugin
+}
+
+// FlexVolumeUnmounter is the disk that will be cleaned by this plugin.
+type flexVolumeUnmounter struct {
+	*flexVolumeDisk
+	// Runner used to teardown the volume.
+	runner exec.Interface
+	// manager is the utility interface that provides API calls to the
+	// driverName to setup & teardown disks
+	manager flexVolumeManager
+	volume.MetricsNil
+}
+
+// FlexVolumeMounter is the disk that will be exposed by this plugin.
+type flexVolumeMounter struct {
+	*flexVolumeDisk
+	// fsType is the type of the filesystem to create on the volume.
+	fsType string
+	// readOnly specifies whether the disk will be setup as read-only.
+	readOnly bool
+	// options are the extra params that will be passed to the plugin
+	// driverName.
+	options map[string]string
+	// Runner used to setup the volume.
+	runner exec.Interface
+	// manager is the utility interface that provides API calls to the
+	// driverName to setup & teardown disks
+	manager flexVolumeManager
+	// blockDeviceMounter provides the interface to create filesystem if the
+	// filesystem doesn't exist.
+	blockDeviceMounter mount.Interface
+	volume.MetricsNil
+}
+
+// SetUp creates new directory.
+func (f *flexVolumeMounter) SetUp(fsGroup *int64) error {
+	return f.SetUpAt(f.GetPath(), fsGroup)
+}
+
+// GetAttributes get the flex volume attributes. The attributes will be queried
+// using plugin callout after we finalize the callout syntax.
+func (f flexVolumeMounter) GetAttributes() volume.Attributes {
+	return volume.Attributes{
+		ReadOnly:        f.readOnly,
+		Managed:         false,
+		SupportsSELinux: false,
+	}
+}
+
+// Checks prior to mount operations to verify that the required components (binaries, etc.)
+// to mount the volume are available on the underlying node.
+// If not, it returns an error
+func (f *flexVolumeMounter) CanMount() error {
+	return nil
+}
+
+// flexVolumeManager is the abstract interface to flex volume ops.
+type flexVolumeManager interface {
+	// Attaches the disk to the kubelet's host machine.
+	attach(mounter *flexVolumeMounter) (string, error)
+	// Detaches the disk from the kubelet's host machine.
+	detach(unmounter *flexVolumeUnmounter, dir string) error
+	// Mounts the disk on the Kubelet's host machine.
+	mount(mounter *flexVolumeMounter, mnt, dir string) error
+	// Unmounts the disk from the Kubelet's host machine.
+	unmount(unounter *flexVolumeUnmounter, dir string) error
+}
+
+// SetUpAt creates new directory.
+func (f *flexVolumeMounter) SetUpAt(dir string, fsGroup *int64) error {
+
+	notmnt, err := f.blockDeviceMounter.IsLikelyNotMountPoint(dir)
+	if err != nil && !os.IsNotExist(err) {
+		glog.Errorf("Cannot validate mount point: %s %v", dir, err)
+		return err
+	}
+	if !notmnt {
+		return nil
+	}
+
+	if f.options == nil {
+		f.options = make(map[string]string)
+	}
+
+	f.options[optionFSType] = f.fsType
+
+	// Read write mount options.
+	if f.readOnly {
+		f.options[optionReadWrite] = "ro"
+	} else {
+		f.options[optionReadWrite] = "rw"
+	}
+
+	// Extract secret and pass it as options.
+	for name, secret := range f.secrets {
+		f.options[optionKeySecret+"/"+name] = secret
+	}
+
+	glog.V(4).Infof("attempting to attach volume: %s with options %v", f.volName, f.options)
+	device, err := f.manager.attach(f)
+	if err != nil {
+		if !isCmdNotSupportedErr(err) {
+			glog.Errorf("failed to attach volume: %s", f.volName)
+			return err
+		}
+		// Attach not supported or required. Continue to mount.
+	}
+
+	glog.V(4).Infof("attempting to mount volume: %s", f.volName)
+	if err := f.manager.mount(f, device, dir); err != nil {
+		if !isCmdNotSupportedErr(err) {
+			glog.Errorf("failed to mount volume: %s", f.volName)
+			return err
+		}
+		options := make([]string, 0)
+
+		if f.readOnly {
+			options = append(options, "ro")
+		} else {
+			options = append(options, "rw")
+		}
+		// Extract secret and pass it as options.
+		for name, secret := range f.secrets {
+			f.options[optionKeySecret+"/"+name] = secret
+		}
+
+		os.MkdirAll(dir, 0750)
+		// Mount not supported by driver. Use core mounting logic.
+		glog.V(4).Infof("attempting to mount the volume: %s to device: %s", f.volName, device)
+		err = f.blockDeviceMounter.Mount(string(device), dir, f.fsType, options)
+		if err != nil {
+			glog.Errorf("failed to mount the volume: %s to device: %s, error: %v", f.volName, device, err)
+			return err
+		}
+	}
+
+	glog.V(4).Infof("Successfully mounted volume: %s on device: %s", f.volName, device)
+	return nil
+}
+
+// IsReadOnly returns true if the volume is read only.
+func (f *flexVolumeMounter) IsReadOnly() bool {
+	return f.readOnly
+}
+
+// GetPathFromPlugin gets the actual volume mount directory based on plugin.
+func (f *flexVolumeDisk) GetPath() string {
+	name := f.driverName
+	return f.plugin.host.GetPodVolumeDir(f.podUID, utilstrings.EscapeQualifiedNameForDisk(name), f.volName)
+}
+
+// TearDown simply deletes everything in the directory.
+func (f *flexVolumeUnmounter) TearDown() error {
+	path := f.GetPath()
+	return f.TearDownAt(path)
+}
+
+// TearDownAt simply deletes everything in the directory.
+func (f *flexVolumeUnmounter) TearDownAt(dir string) error {
+
+	notmnt, err := f.mounter.IsLikelyNotMountPoint(dir)
+	if err != nil {
+		glog.Errorf("Error checking mount point %s, error: %v", dir, err)
+		return err
+	}
+	if notmnt {
+		return os.Remove(dir)
+	}
+
+	device, refCount, err := mount.GetDeviceNameFromMount(f.mounter, dir)
+	if err != nil {
+		glog.Errorf("Failed to get reference count for volume: %s", dir)
+		return err
+	}
+
+	if err := f.manager.unmount(f, dir); err != nil {
+		if !isCmdNotSupportedErr(err) {
+			glog.Errorf("Failed to unmount volume %s", f.volName)
+			return err
+		}
+		// Unmount not supported by the driver. Use core unmount logic.
+		if err := f.mounter.Unmount(dir); err != nil {
+			glog.Errorf("Failed to unmount volume: %s, error: %v", dir, err)
+			return err
+		}
+	}
+
+	if refCount == 1 {
+		if err := f.manager.detach(f, device); err != nil {
+			if !isCmdNotSupportedErr(err) {
+				glog.Errorf("Failed to teardown volume: %s, error: %v", dir, err)
+				return err
+			}
+			// Teardown not supported by driver. Unmount is good enough.
+		}
+	}
+
+	notmnt, err = f.mounter.IsLikelyNotMountPoint(dir)
+	if err != nil {
+		glog.Errorf("Error checking mount point %s, error: %v", dir, err)
+		return err
+	}
+	if notmnt {
+		return os.Remove(dir)
+	}
+
+	return nil
+}
+
+func getVolumeSource(spec *volume.Spec) (*v1.FlexVolumeSource, bool, error) {
+	if spec.Volume != nil && spec.Volume.FlexVolume != nil {
+		return spec.Volume.FlexVolume, spec.Volume.FlexVolume.ReadOnly, nil
+	} else if spec.PersistentVolume != nil &&
+		spec.PersistentVolume.Spec.FlexVolume != nil {
+		return spec.PersistentVolume.Spec.FlexVolume, spec.ReadOnly, nil
+	}
+
+	return nil, false, fmt.Errorf("Spec does not reference a Flex volume type")
+}

vendor/k8s.io/kubernetes/pkg/volume/flexvolume/flexvolume_test.go

@@ -0,0 +1,417 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package flexvolume
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"os"
+	"path"
+	"testing"
+	"text/template"
+
+	"k8s.io/kubernetes/pkg/api/v1"
+	"k8s.io/kubernetes/pkg/types"
+	"k8s.io/kubernetes/pkg/util/exec"
+	"k8s.io/kubernetes/pkg/util/mount"
+	utiltesting "k8s.io/kubernetes/pkg/util/testing"
+	"k8s.io/kubernetes/pkg/volume"
+	volumetest "k8s.io/kubernetes/pkg/volume/testing"
+)
+
+const execScriptTempl1 = `#!/bin/bash
+if [ "$1" == "init" -a $# -eq 1 ]; then
+  echo -n '{
+    "status": "Success"
+  }'
+  exit 0
+fi
+
+PATH=$2
+if [ "$1" == "attach" -a $# -eq 2 ]; then
+  echo -n '{
+    "device": "{{.DevicePath}}",
+    "status": "Success"
+  }'
+  exit 0
+elif [ "$1" == "detach" -a $# -eq 2 ]; then
+  echo -n '{
+    "status": "Success"
+  }'
+  exit 0
+elif [ "$1" == "mount" -a $# -eq 4 ]; then
+  echo -n '{
+    "status": "Not supported"
+  }'
+  exit 0
+elif [ "$1" == "unmount" -a $# -eq 2 ]; then
+  echo -n '{
+    "status": "Not supported"
+  }'
+  exit 0
+fi
+
+echo -n '{
+  "status": "Failure",
+  "reason": "Invalid usage"
+}'
+exit 1
+
+# Direct the arguments to a file to be tested against later
+echo -n $@ &> {{.OutputFile}}
+`
+
+const execScriptTempl2 = `#!/bin/bash
+if [ "$1" == "init" -a $# -eq 1 ]; then
+  echo -n '{
+    "status": "Success"
+  }'
+  exit 0
+fi
+
+if [ "$1" == "attach" -a $# -eq 2 ]; then
+  echo -n '{
+    "status": "Not supported"
+  }'
+  exit 0
+elif [ "$1" == "detach" -a $# -eq 2 ]; then
+  echo -n '{
+    "status": "Not supported"
+  }'
+  exit 0
+elif [ "$1" == "mount" -a $# -eq 4 ]; then
+  PATH=$2
+  /bin/mkdir -p $PATH
+  if [ $? -ne 0 ]; then
+    echo -n '{
+      "status": "Failure",
+      "reason": "Failed to create $PATH"
+    }'
+    exit 1
+  fi
+  echo -n '{
+    "status": "Success"
+  }'
+  exit 0
+elif [ "$1" == "unmount" -a $# -eq 2 ]; then
+  PATH=$2
+  /bin/rm -r $PATH
+  if [ $? -ne 0 ]; then
+    echo -n '{
+      "status": "Failure",
+      "reason": "Failed to cleanup $PATH"
+    }'
+    exit 1
+  fi
+  echo -n '{
+    "status": "Success"
+  }'
+  exit 0
+fi
+
+echo -n '{
+  "status": "Failure",
+  "reason": "Invalid usage"
+}'
+exit 1
+
+# Direct the arguments to a file to be tested against later
+echo -n $@ &> {{.OutputFile}}
+`
+
+func installPluginUnderTest(t *testing.T, vendorName, plugName, tmpDir string, execScriptTempl string, execTemplateData *map[string]interface{}) {
+	vendoredName := plugName
+	if vendorName != "" {
+		vendoredName = fmt.Sprintf("%s~%s", vendorName, plugName)
+	}
+	pluginDir := path.Join(tmpDir, vendoredName)
+	err := os.MkdirAll(pluginDir, 0777)
+	if err != nil {
+		t.Errorf("Failed to create plugin: %v", err)
+	}
+	pluginExec := path.Join(pluginDir, plugName)
+	f, err := os.Create(pluginExec)
+	if err != nil {
+		t.Errorf("Failed to install plugin")
+	}
+	err = f.Chmod(0777)
+	if err != nil {
+		t.Errorf("Failed to set exec perms on plugin")
+	}
+	if execTemplateData == nil {
+		execTemplateData = &map[string]interface{}{
+			"DevicePath": "/dev/sdx",
+			"OutputFile": path.Join(pluginDir, plugName+".out"),
+		}
+	}
+
+	tObj := template.Must(template.New("test").Parse(execScriptTempl))
+	buf := &bytes.Buffer{}
+	if err := tObj.Execute(buf, *execTemplateData); err != nil {
+		t.Errorf("Error in executing script template - %v", err)
+	}
+	execScript := buf.String()
+	_, err = f.WriteString(execScript)
+	if err != nil {
+		t.Errorf("Failed to write plugin exec")
+	}
+	f.Close()
+}
+
+func TestCanSupport(t *testing.T) {
+	tmpDir, err := utiltesting.MkTmpdir("flexvolume_test")
+	if err != nil {
+		t.Fatalf("error creating temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	plugMgr := volume.VolumePluginMgr{}
+	installPluginUnderTest(t, "kubernetes.io", "fakeAttacher", tmpDir, execScriptTempl1, nil)
+	plugMgr.InitPlugins(ProbeVolumePlugins(tmpDir), volumetest.NewFakeVolumeHost("fake", nil, nil))
+	plugin, err := plugMgr.FindPluginByName("kubernetes.io/fakeAttacher")
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	if plugin.GetPluginName() != "kubernetes.io/fakeAttacher" {
+		t.Errorf("Wrong name: %s", plugin.GetPluginName())
+	}
+	if !plugin.CanSupport(&volume.Spec{Volume: &v1.Volume{VolumeSource: v1.VolumeSource{FlexVolume: &v1.FlexVolumeSource{Driver: "kubernetes.io/fakeAttacher"}}}}) {
+		t.Errorf("Expected true")
+	}
+	if !plugin.CanSupport(&volume.Spec{PersistentVolume: &v1.PersistentVolume{Spec: v1.PersistentVolumeSpec{PersistentVolumeSource: v1.PersistentVolumeSource{FlexVolume: &v1.FlexVolumeSource{Driver: "kubernetes.io/fakeAttacher"}}}}}) {
+		t.Errorf("Expected true")
+	}
+	if plugin.CanSupport(&volume.Spec{Volume: &v1.Volume{VolumeSource: v1.VolumeSource{}}}) {
+		t.Errorf("Expected false")
+	}
+}
+
+func TestGetAccessModes(t *testing.T) {
+	tmpDir, err := utiltesting.MkTmpdir("flexvolume_test")
+	if err != nil {
+		t.Fatalf("error creating temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	plugMgr := volume.VolumePluginMgr{}
+	installPluginUnderTest(t, "kubernetes.io", "fakeAttacher", tmpDir, execScriptTempl1, nil)
+	plugMgr.InitPlugins(ProbeVolumePlugins(tmpDir), volumetest.NewFakeVolumeHost(tmpDir, nil, nil))
+
+	plugin, err := plugMgr.FindPersistentPluginByName("kubernetes.io/fakeAttacher")
+	if err != nil {
+		t.Fatalf("Can't find the plugin by name")
+	}
+	if !contains(plugin.GetAccessModes(), v1.ReadWriteOnce) || !contains(plugin.GetAccessModes(), v1.ReadOnlyMany) {
+		t.Errorf("Expected two AccessModeTypes:  %s and %s", v1.ReadWriteOnce, v1.ReadOnlyMany)
+	}
+}
+
+func contains(modes []v1.PersistentVolumeAccessMode, mode v1.PersistentVolumeAccessMode) bool {
+	for _, m := range modes {
+		if m == mode {
+			return true
+		}
+	}
+	return false
+}
+
+func doTestPluginAttachDetach(t *testing.T, spec *volume.Spec, tmpDir string) {
+	plugMgr := volume.VolumePluginMgr{}
+	installPluginUnderTest(t, "kubernetes.io", "fakeAttacher", tmpDir, execScriptTempl1, nil)
+	plugMgr.InitPlugins(ProbeVolumePlugins(tmpDir), volumetest.NewFakeVolumeHost(tmpDir, nil, nil))
+	plugin, err := plugMgr.FindPluginByName("kubernetes.io/fakeAttacher")
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	fake := &mount.FakeMounter{}
+	pod := &v1.Pod{ObjectMeta: v1.ObjectMeta{UID: types.UID("poduid")}}
+	secretMap := make(map[string]string)
+	secretMap["flexsecret"] = base64.StdEncoding.EncodeToString([]byte("foo"))
+	mounter, err := plugin.(*flexVolumePlugin).newMounterInternal(spec, pod, &flexVolumeUtil{}, fake, exec.New(), secretMap)
+	volumePath := mounter.GetPath()
+	if err != nil {
+		t.Errorf("Failed to make a new Mounter: %v", err)
+	}
+	if mounter == nil {
+		t.Errorf("Got a nil Mounter")
+	}
+	path := mounter.GetPath()
+	expectedPath := fmt.Sprintf("%s/pods/poduid/volumes/kubernetes.io~fakeAttacher/vol1", tmpDir)
+	if path != expectedPath {
+		t.Errorf("Unexpected path, expected %q, got: %q", expectedPath, path)
+	}
+	if err := mounter.SetUp(nil); err != nil {
+		t.Errorf("Expected success, got: %v", err)
+	}
+	if _, err := os.Stat(volumePath); err != nil {
+		if os.IsNotExist(err) {
+			t.Errorf("SetUp() failed, volume path not created: %s", volumePath)
+		} else {
+			t.Errorf("SetUp() failed: %v", err)
+		}
+	}
+	t.Logf("Setup successful")
+	if mounter.(*flexVolumeMounter).readOnly {
+		t.Errorf("The volume source should not be read-only and it is.")
+	}
+
+	if len(fake.Log) != 1 {
+		t.Errorf("Mount was not called exactly one time. It was called %d times.", len(fake.Log))
+	} else {
+		if fake.Log[0].Action != mount.FakeActionMount {
+			t.Errorf("Unexpected mounter action: %#v", fake.Log[0])
+		}
+	}
+	fake.ResetLog()
+
+	unmounter, err := plugin.(*flexVolumePlugin).newUnmounterInternal("vol1", types.UID("poduid"), &flexVolumeUtil{}, fake, exec.New())
+	if err != nil {
+		t.Errorf("Failed to make a new Unmounter: %v", err)
+	}
+	if unmounter == nil {
+		t.Errorf("Got a nil Unmounter")
+	}
+	if err := unmounter.TearDown(); err != nil {
+		t.Errorf("Expected success, got: %v", err)
+	}
+	if _, err := os.Stat(volumePath); err == nil {
+		t.Errorf("TearDown() failed, volume path still exists: %s", volumePath)
+	} else if !os.IsNotExist(err) {
+		t.Errorf("SetUp() failed: %v", err)
+	}
+	if len(fake.Log) != 1 {
+		t.Errorf("Unmount was not called exactly one time. It was called %d times.", len(fake.Log))
+	} else {
+		if fake.Log[0].Action != mount.FakeActionUnmount {
+			t.Errorf("Unexpected mounter action: %#v", fake.Log[0])
+		}
+	}
+
+	fake.ResetLog()
+}
+
+func doTestPluginMountUnmount(t *testing.T, spec *volume.Spec, tmpDir string) {
+	tmpDir, err := utiltesting.MkTmpdir("flexvolume_test")
+	if err != nil {
+		t.Fatalf("error creating temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	plugMgr := volume.VolumePluginMgr{}
+	installPluginUnderTest(t, "kubernetes.io", "fakeMounter", tmpDir, execScriptTempl2, nil)
+	plugMgr.InitPlugins(ProbeVolumePlugins(tmpDir), volumetest.NewFakeVolumeHost(tmpDir, nil, nil))
+	plugin, err := plugMgr.FindPluginByName("kubernetes.io/fakeMounter")
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	fake := &mount.FakeMounter{}
+	pod := &v1.Pod{ObjectMeta: v1.ObjectMeta{UID: types.UID("poduid")}}
+	// Use nil secret to test for nil secret case.
+	mounter, err := plugin.(*flexVolumePlugin).newMounterInternal(spec, pod, &flexVolumeUtil{}, fake, exec.New(), nil)
+	volumePath := mounter.GetPath()
+	if err != nil {
+		t.Errorf("Failed to make a new Mounter: %v", err)
+	}
+	if mounter == nil {
+		t.Errorf("Got a nil Mounter")
+	}
+	path := mounter.GetPath()
+	expectedPath := fmt.Sprintf("%s/pods/poduid/volumes/kubernetes.io~fakeMounter/vol1", tmpDir)
+	if path != expectedPath {
+		t.Errorf("Unexpected path, expected %q, got: %q", expectedPath, path)
+	}
+	if err := mounter.SetUp(nil); err != nil {
+		t.Errorf("Expected success, got: %v", err)
+	}
+	if _, err := os.Stat(volumePath); err != nil {
+		if os.IsNotExist(err) {
+			t.Errorf("SetUp() failed, volume path not created: %s", volumePath)
+		} else {
+			t.Errorf("SetUp() failed: %v", err)
+		}
+	}
+	t.Logf("Setup successful")
+	if mounter.(*flexVolumeMounter).readOnly {
+		t.Errorf("The volume source should not be read-only and it is.")
+	}
+
+	unmounter, err := plugin.(*flexVolumePlugin).newUnmounterInternal("vol1", types.UID("poduid"), &flexVolumeUtil{}, fake, exec.New())
+	if err != nil {
+		t.Errorf("Failed to make a new Unmounter: %v", err)
+	}
+	if unmounter == nil {
+		t.Errorf("Got a nil Unmounter")
+	}
+	if err := unmounter.TearDown(); err != nil {
+		t.Errorf("Expected success, got: %v", err)
+	}
+	if _, err := os.Stat(volumePath); err == nil {
+		t.Errorf("TearDown() failed, volume path still exists: %s", volumePath)
+	} else if !os.IsNotExist(err) {
+		t.Errorf("SetUp() failed: %v", err)
+	}
+}
+
+func TestPluginVolumeAttacher(t *testing.T) {
+	tmpDir, err := utiltesting.MkTmpdir("flexvolume_test")
+	if err != nil {
+		t.Fatalf("error creating temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	vol := &v1.Volume{
+		Name:         "vol1",
+		VolumeSource: v1.VolumeSource{FlexVolume: &v1.FlexVolumeSource{Driver: "kubernetes.io/fakeAttacher", ReadOnly: false}},
+	}
+	doTestPluginAttachDetach(t, volume.NewSpecFromVolume(vol), tmpDir)
+}
+
+func TestPluginVolumeMounter(t *testing.T) {
+	tmpDir, err := utiltesting.MkTmpdir("flexvolume_test")
+	if err != nil {
+		t.Fatalf("error creating temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	vol := &v1.Volume{
+		Name:         "vol1",
+		VolumeSource: v1.VolumeSource{FlexVolume: &v1.FlexVolumeSource{Driver: "kubernetes.io/fakeMounter", ReadOnly: false}},
+	}
+	doTestPluginMountUnmount(t, volume.NewSpecFromVolume(vol), tmpDir)
+}
+
+func TestPluginPersistentVolume(t *testing.T) {
+	tmpDir, err := utiltesting.MkTmpdir("flexvolume_test")
+	if err != nil {
+		t.Fatalf("error creating temp dir: %v", err)
+	}
+	defer os.RemoveAll(tmpDir)
+
+	vol := &v1.PersistentVolume{
+		ObjectMeta: v1.ObjectMeta{
+			Name: "vol1",
+		},
+		Spec: v1.PersistentVolumeSpec{
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				FlexVolume: &v1.FlexVolumeSource{Driver: "kubernetes.io/fakeAttacher", ReadOnly: false},
+			},
+		},
+	}
+
+	doTestPluginAttachDetach(t, volume.NewSpecFromPersistentVolume(vol, false), tmpDir)
+}

vendor/k8s.io/kubernetes/pkg/volume/flexvolume/flexvolume_util.go

@@ -0,0 +1,221 @@
+/*
+Copyright 2015 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package flexvolume
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+
+	"github.com/golang/glog"
+
+	"k8s.io/kubernetes/pkg/util/exec"
+)
+
+const (
+	initCmd    = "init"
+	attachCmd  = "attach"
+	detachCmd  = "detach"
+	mountCmd   = "mount"
+	unmountCmd = "unmount"
+
+	optionFSType    = "kubernetes.io/fsType"
+	optionReadWrite = "kubernetes.io/readwrite"
+	optionKeySecret = "kubernetes.io/secret"
+)
+
+const (
+	// StatusSuccess represents the successful completion of command.
+	StatusSuccess = "Success"
+	// StatusFailed represents that the command failed.
+	StatusFailure = "Failed"
+	// StatusNotSupported represents that the command is not supported.
+	StatusNotSupported = "Not supported"
+)
+
+// FlexVolumeDriverStatus represents the return value of the driver callout.
+type FlexVolumeDriverStatus struct {
+	// Status of the callout. One of "Success" or "Failure".
+	Status string
+	// Message is the reason for failure.
+	Message string
+	// Device assigned by the driver.
+	Device string `json:"device"`
+}
+
+// flexVolumeUtil is the utility structure to setup and teardown devices from
+// the host.
+type flexVolumeUtil struct{}
+
+// isCmdNotSupportedErr checks if the error corresponds to command not supported by
+// driver.
+func isCmdNotSupportedErr(err error) bool {
+	if err.Error() == StatusNotSupported {
+		return true
+	}
+
+	return false
+}
+
+// handleCmdResponse processes the command output and returns the appropriate
+// error code or message.
+func handleCmdResponse(cmd string, output []byte) (*FlexVolumeDriverStatus, error) {
+	var status FlexVolumeDriverStatus
+	if err := json.Unmarshal(output, &status); err != nil {
+		glog.Errorf("Failed to unmarshal output for command: %s, output: %s, error: %s", cmd, output, err.Error())
+		return nil, err
+	} else if status.Status == StatusNotSupported {
+		glog.V(5).Infof("%s command is not supported by the driver", cmd)
+		return nil, errors.New(status.Status)
+	} else if status.Status != StatusSuccess {
+		errMsg := fmt.Sprintf("%s command failed, status: %s, reason: %s", cmd, status.Status, status.Message)
+		glog.Errorf(errMsg)
+		return nil, fmt.Errorf("%s", errMsg)
+	}
+
+	return &status, nil
+}
+
+// init initializes the plugin.
+func (u *flexVolumeUtil) init(plugin *flexVolumePlugin) error {
+	// call the init script
+	output, err := exec.New().Command(plugin.getExecutable(), initCmd).CombinedOutput()
+	if err != nil {
+		glog.Errorf("Failed to init driver: %s, error: %s", plugin.driverName, err.Error())
+		_, err := handleCmdResponse(initCmd, output)
+		return err
+	}
+
+	glog.V(5).Infof("Successfully initialized driver %s", plugin.driverName)
+	return nil
+}
+
+// Attach exposes a volume on the host.
+func (u *flexVolumeUtil) attach(f *flexVolumeMounter) (string, error) {
+	execPath := f.execPath
+
+	var options string
+	if f.options != nil {
+		out, err := json.Marshal(f.options)
+		if err != nil {
+			glog.Errorf("Failed to marshal plugin options, error: %s", err.Error())
+			return "", err
+		}
+		if len(out) != 0 {
+			options = string(out)
+		} else {
+			options = ""
+		}
+	}
+
+	cmd := f.runner.Command(execPath, attachCmd, options)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		glog.Errorf("Failed to attach volume %s, output: %s, error: %s", f.volName, output, err.Error())
+		_, err := handleCmdResponse(attachCmd, output)
+		return "", err
+	}
+
+	status, err := handleCmdResponse(attachCmd, output)
+	if err != nil {
+		return "", err
+	}
+
+	glog.Infof("Successfully attached volume %s on device: %s", f.volName, status.Device)
+
+	return status.Device, nil
+}
+
+// Detach detaches a volume from the host.
+func (u *flexVolumeUtil) detach(f *flexVolumeUnmounter, mntDevice string) error {
+	execPath := f.execPath
+
+	// Executable provider command.
+	cmd := f.runner.Command(execPath, detachCmd, mntDevice)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		glog.Errorf("Failed to detach volume %s, output: %s, error: %s", f.volName, output, err.Error())
+		_, err := handleCmdResponse(detachCmd, output)
+		return err
+	}
+
+	_, err = handleCmdResponse(detachCmd, output)
+	if err != nil {
+		return err
+	}
+
+	glog.Infof("Successfully detached volume %s on device: %s", f.volName, mntDevice)
+	return nil
+}
+
+// Mount mounts the volume on the host.
+func (u *flexVolumeUtil) mount(f *flexVolumeMounter, mntDevice, dir string) error {
+	execPath := f.execPath
+
+	var options string
+	if f.options != nil {
+		out, err := json.Marshal(f.options)
+		if err != nil {
+			glog.Errorf("Failed to marshal plugin options, error: %s", err.Error())
+			return err
+		}
+		if len(out) != 0 {
+			options = string(out)
+		} else {
+			options = ""
+		}
+	}
+
+	// Executable provider command.
+	cmd := f.runner.Command(execPath, mountCmd, dir, mntDevice, options)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		glog.Errorf("Failed to mount volume %s, output: %s, error: %s", f.volName, output, err.Error())
+		_, err := handleCmdResponse(mountCmd, output)
+		return err
+	}
+
+	_, err = handleCmdResponse(mountCmd, output)
+	if err != nil {
+		return err
+	}
+
+	glog.Infof("Successfully mounted volume %s on dir: %s", f.volName, dir)
+	return nil
+}
+
+// Unmount unmounts the volume on the host.
+func (u *flexVolumeUtil) unmount(f *flexVolumeUnmounter, dir string) error {
+	execPath := f.execPath
+
+	// Executable provider command.
+	cmd := f.runner.Command(execPath, unmountCmd, dir)
+	output, err := cmd.CombinedOutput()
+	if err != nil {
+		glog.Errorf("Failed to unmount volume %s, output: %s, error: %s", f.volName, output, err.Error())
+		_, err := handleCmdResponse(unmountCmd, output)
+		return err
+	}
+
+	_, err = handleCmdResponse(unmountCmd, output)
+	if err != nil {
+		return err
+	}
+
+	glog.Infof("Successfully unmounted volume %s on dir: %s", f.volName, dir)
+	return nil
+}