vendor files

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

@@ -0,0 +1,58 @@
+package(default_visibility = ["//visibility:public"])
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_library",
+    "go_test",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = [
+        "doc.go",
+        "host_path.go",
+    ],
+    importpath = "k8s.io/kubernetes/pkg/volume/host_path",
+    deps = [
+        "//pkg/util/mount:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/util/volumehelper:go_default_library",
+        "//pkg/volume/validation:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/uuid:go_default_library",
+    ],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs = ["host_path_test.go"],
+    importpath = "k8s.io/kubernetes/pkg/volume/host_path",
+    library = ":go_default_library",
+    deps = [
+        "//pkg/util/file:go_default_library",
+        "//pkg/util/mount:go_default_library",
+        "//pkg/volume:go_default_library",
+        "//pkg/volume/testing:go_default_library",
+        "//vendor/k8s.io/api/core/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/api/resource:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
+        "//vendor/k8s.io/apimachinery/pkg/util/uuid:go_default_library",
+        "//vendor/k8s.io/client-go/kubernetes/fake:go_default_library",
+    ],
+)
+
+filegroup(
+    name = "package-srcs",
+    srcs = glob(["**"]),
+    tags = ["automanaged"],
+    visibility = ["//visibility:private"],
+)
+
+filegroup(
+    name = "all-srcs",
+    srcs = [":package-srcs"],
+    tags = ["automanaged"],
+)

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

@@ -0,0 +1,10 @@
+approvers:
+- pmorie
+- saad-ali
+- thockin
+reviewers:
+- saad-ali
+- jsafrane
+- rootfs
+- jingxu97
+- msau42

vendor/k8s.io/kubernetes/pkg/volume/host_path/doc.go

@@ -0,0 +1,19 @@
+/*
+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 host_path contains the internal representation of hostPath
+// volumes.
+package host_path // import "k8s.io/kubernetes/pkg/volume/host_path"

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

@@ -0,0 +1,455 @@
+/*
+Copyright 2014 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 host_path
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+
+	"k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/uuid"
+	"k8s.io/kubernetes/pkg/util/mount"
+	"k8s.io/kubernetes/pkg/volume"
+	"k8s.io/kubernetes/pkg/volume/util/volumehelper"
+	"k8s.io/kubernetes/pkg/volume/validation"
+)
+
+// This is the primary entrypoint for volume plugins.
+// The volumeConfig arg provides the ability to configure volume behavior.  It is implemented as a pointer to allow nils.
+// The hostPathPlugin is used to store the volumeConfig and give it, when needed, to the func that Recycles.
+// Tests that exercise recycling should not use this func but instead use ProbeRecyclablePlugins() to override default behavior.
+func ProbeVolumePlugins(volumeConfig volume.VolumeConfig) []volume.VolumePlugin {
+	return []volume.VolumePlugin{
+		&hostPathPlugin{
+			host:   nil,
+			config: volumeConfig,
+		},
+	}
+}
+
+type hostPathPlugin struct {
+	host   volume.VolumeHost
+	config volume.VolumeConfig
+}
+
+var _ volume.VolumePlugin = &hostPathPlugin{}
+var _ volume.PersistentVolumePlugin = &hostPathPlugin{}
+var _ volume.RecyclableVolumePlugin = &hostPathPlugin{}
+var _ volume.DeletableVolumePlugin = &hostPathPlugin{}
+var _ volume.ProvisionableVolumePlugin = &hostPathPlugin{}
+
+const (
+	hostPathPluginName = "kubernetes.io/host-path"
+)
+
+func (plugin *hostPathPlugin) Init(host volume.VolumeHost) error {
+	plugin.host = host
+	return nil
+}
+
+func (plugin *hostPathPlugin) GetPluginName() string {
+	return hostPathPluginName
+}
+
+func (plugin *hostPathPlugin) GetVolumeName(spec *volume.Spec) (string, error) {
+	volumeSource, _, err := getVolumeSource(spec)
+	if err != nil {
+		return "", err
+	}
+
+	return volumeSource.Path, nil
+}
+
+func (plugin *hostPathPlugin) CanSupport(spec *volume.Spec) bool {
+	return (spec.PersistentVolume != nil && spec.PersistentVolume.Spec.HostPath != nil) ||
+		(spec.Volume != nil && spec.Volume.HostPath != nil)
+}
+
+func (plugin *hostPathPlugin) RequiresRemount() bool {
+	return false
+}
+
+func (plugin *hostPathPlugin) SupportsMountOption() bool {
+	return false
+}
+
+func (plugin *hostPathPlugin) SupportsBulkVolumeVerification() bool {
+	return false
+}
+
+func (plugin *hostPathPlugin) GetAccessModes() []v1.PersistentVolumeAccessMode {
+	return []v1.PersistentVolumeAccessMode{
+		v1.ReadWriteOnce,
+	}
+}
+
+func (plugin *hostPathPlugin) NewMounter(spec *volume.Spec, pod *v1.Pod, opts volume.VolumeOptions) (volume.Mounter, error) {
+	hostPathVolumeSource, readOnly, err := getVolumeSource(spec)
+	if err != nil {
+		return nil, err
+	}
+
+	path := hostPathVolumeSource.Path
+	pathType := new(v1.HostPathType)
+	if hostPathVolumeSource.Type == nil {
+		*pathType = v1.HostPathUnset
+	} else {
+		pathType = hostPathVolumeSource.Type
+	}
+	return &hostPathMounter{
+		hostPath: &hostPath{path: path, pathType: pathType},
+		readOnly: readOnly,
+		mounter:  plugin.host.GetMounter(plugin.GetPluginName()),
+	}, nil
+}
+
+func (plugin *hostPathPlugin) NewUnmounter(volName string, podUID types.UID) (volume.Unmounter, error) {
+	return &hostPathUnmounter{&hostPath{
+		path: "",
+	}}, nil
+}
+
+// Recycle recycles/scrubs clean a HostPath volume.
+// Recycle blocks until the pod has completed or any error occurs.
+// HostPath recycling only works in single node clusters and is meant for testing purposes only.
+func (plugin *hostPathPlugin) Recycle(pvName string, spec *volume.Spec, eventRecorder volume.RecycleEventRecorder) error {
+	if spec.PersistentVolume == nil || spec.PersistentVolume.Spec.HostPath == nil {
+		return fmt.Errorf("spec.PersistentVolumeSource.HostPath is nil")
+	}
+
+	pod := plugin.config.RecyclerPodTemplate
+	timeout := volume.CalculateTimeoutForVolume(plugin.config.RecyclerMinimumTimeout, plugin.config.RecyclerTimeoutIncrement, spec.PersistentVolume)
+	// overrides
+	pod.Spec.ActiveDeadlineSeconds = &timeout
+	pod.Spec.Volumes[0].VolumeSource = v1.VolumeSource{
+		HostPath: &v1.HostPathVolumeSource{
+			Path: spec.PersistentVolume.Spec.HostPath.Path,
+		},
+	}
+	return volume.RecycleVolumeByWatchingPodUntilCompletion(pvName, pod, plugin.host.GetKubeClient(), eventRecorder)
+}
+
+func (plugin *hostPathPlugin) NewDeleter(spec *volume.Spec) (volume.Deleter, error) {
+	return newDeleter(spec, plugin.host)
+}
+
+func (plugin *hostPathPlugin) NewProvisioner(options volume.VolumeOptions) (volume.Provisioner, error) {
+	if !plugin.config.ProvisioningEnabled {
+		return nil, fmt.Errorf("Provisioning in volume plugin %q is disabled", plugin.GetPluginName())
+	}
+	return newProvisioner(options, plugin.host, plugin)
+}
+
+func (plugin *hostPathPlugin) ConstructVolumeSpec(volumeName, mountPath string) (*volume.Spec, error) {
+	hostPathVolume := &v1.Volume{
+		Name: volumeName,
+		VolumeSource: v1.VolumeSource{
+			HostPath: &v1.HostPathVolumeSource{
+				Path: volumeName,
+			},
+		},
+	}
+	return volume.NewSpecFromVolume(hostPathVolume), nil
+}
+
+func newDeleter(spec *volume.Spec, host volume.VolumeHost) (volume.Deleter, error) {
+	if spec.PersistentVolume != nil && spec.PersistentVolume.Spec.HostPath == nil {
+		return nil, fmt.Errorf("spec.PersistentVolumeSource.HostPath is nil")
+	}
+	path := spec.PersistentVolume.Spec.HostPath.Path
+	return &hostPathDeleter{name: spec.Name(), path: path, host: host}, nil
+}
+
+func newProvisioner(options volume.VolumeOptions, host volume.VolumeHost, plugin *hostPathPlugin) (volume.Provisioner, error) {
+	return &hostPathProvisioner{options: options, host: host, plugin: plugin}, nil
+}
+
+// HostPath volumes represent a bare host file or directory mount.
+// The direct at the specified path will be directly exposed to the container.
+type hostPath struct {
+	path     string
+	pathType *v1.HostPathType
+	volume.MetricsNil
+}
+
+func (hp *hostPath) GetPath() string {
+	return hp.path
+}
+
+type hostPathMounter struct {
+	*hostPath
+	readOnly bool
+	mounter  mount.Interface
+}
+
+var _ volume.Mounter = &hostPathMounter{}
+
+func (b *hostPathMounter) GetAttributes() volume.Attributes {
+	return volume.Attributes{
+		ReadOnly:        b.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 (b *hostPathMounter) CanMount() error {
+	return nil
+}
+
+// SetUp does nothing.
+func (b *hostPathMounter) SetUp(fsGroup *int64) error {
+	err := validation.ValidatePathNoBacksteps(b.GetPath())
+	if err != nil {
+		return fmt.Errorf("invalid HostPath `%s`: %v", b.GetPath(), err)
+	}
+
+	if *b.pathType == v1.HostPathUnset {
+		return nil
+	}
+	return checkType(b.GetPath(), b.pathType, b.mounter)
+}
+
+// SetUpAt does not make sense for host paths - probably programmer error.
+func (b *hostPathMounter) SetUpAt(dir string, fsGroup *int64) error {
+	return fmt.Errorf("SetUpAt() does not make sense for host paths")
+}
+
+func (b *hostPathMounter) GetPath() string {
+	return b.path
+}
+
+type hostPathUnmounter struct {
+	*hostPath
+}
+
+var _ volume.Unmounter = &hostPathUnmounter{}
+
+// TearDown does nothing.
+func (c *hostPathUnmounter) TearDown() error {
+	return nil
+}
+
+// TearDownAt does not make sense for host paths - probably programmer error.
+func (c *hostPathUnmounter) TearDownAt(dir string) error {
+	return fmt.Errorf("TearDownAt() does not make sense for host paths")
+}
+
+// hostPathProvisioner implements a Provisioner for the HostPath plugin
+// This implementation is meant for testing only and only works in a single node cluster.
+type hostPathProvisioner struct {
+	host    volume.VolumeHost
+	options volume.VolumeOptions
+	plugin  *hostPathPlugin
+}
+
+// Create for hostPath simply creates a local /tmp/hostpath_pv/%s directory as a new PersistentVolume.
+// This Provisioner is meant for development and testing only and WILL NOT WORK in a multi-node cluster.
+func (r *hostPathProvisioner) Provision() (*v1.PersistentVolume, error) {
+	fullpath := fmt.Sprintf("/tmp/hostpath_pv/%s", uuid.NewUUID())
+
+	capacity := r.options.PVC.Spec.Resources.Requests[v1.ResourceName(v1.ResourceStorage)]
+	pv := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: r.options.PVName,
+			Annotations: map[string]string{
+				volumehelper.VolumeDynamicallyCreatedByKey: "hostpath-dynamic-provisioner",
+			},
+		},
+		Spec: v1.PersistentVolumeSpec{
+			PersistentVolumeReclaimPolicy: r.options.PersistentVolumeReclaimPolicy,
+			AccessModes:                   r.options.PVC.Spec.AccessModes,
+			Capacity: v1.ResourceList{
+				v1.ResourceName(v1.ResourceStorage): capacity,
+			},
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				HostPath: &v1.HostPathVolumeSource{
+					Path: fullpath,
+				},
+			},
+		},
+	}
+	if len(r.options.PVC.Spec.AccessModes) == 0 {
+		pv.Spec.AccessModes = r.plugin.GetAccessModes()
+	}
+
+	return pv, os.MkdirAll(pv.Spec.HostPath.Path, 0750)
+}
+
+// hostPathDeleter deletes a hostPath PV from the cluster.
+// This deleter only works on a single host cluster and is for testing purposes only.
+type hostPathDeleter struct {
+	name string
+	path string
+	host volume.VolumeHost
+	volume.MetricsNil
+}
+
+func (r *hostPathDeleter) GetPath() string {
+	return r.path
+}
+
+// Delete for hostPath removes the local directory so long as it is beneath /tmp/*.
+// THIS IS FOR TESTING AND LOCAL DEVELOPMENT ONLY!  This message should scare you away from using
+// this deleter for anything other than development and testing.
+func (r *hostPathDeleter) Delete() error {
+	regexp := regexp.MustCompile("/tmp/.+")
+	if !regexp.MatchString(r.GetPath()) {
+		return fmt.Errorf("host_path deleter only supports /tmp/.+ but received provided %s", r.GetPath())
+	}
+	return os.RemoveAll(r.GetPath())
+}
+
+func getVolumeSource(spec *volume.Spec) (*v1.HostPathVolumeSource, bool, error) {
+	if spec.Volume != nil && spec.Volume.HostPath != nil {
+		return spec.Volume.HostPath, spec.ReadOnly, nil
+	} else if spec.PersistentVolume != nil &&
+		spec.PersistentVolume.Spec.HostPath != nil {
+		return spec.PersistentVolume.Spec.HostPath, spec.ReadOnly, nil
+	}
+
+	return nil, false, fmt.Errorf("Spec does not reference an HostPath volume type")
+}
+
+type hostPathTypeChecker interface {
+	Exists() bool
+	IsFile() bool
+	MakeFile() error
+	IsDir() bool
+	MakeDir() error
+	IsBlock() bool
+	IsChar() bool
+	IsSocket() bool
+	GetPath() string
+}
+
+type fileTypeChecker struct {
+	path    string
+	exists  bool
+	mounter mount.Interface
+}
+
+func (ftc *fileTypeChecker) Exists() bool {
+	return ftc.mounter.ExistsPath(ftc.path)
+}
+
+func (ftc *fileTypeChecker) IsFile() bool {
+	if !ftc.Exists() {
+		return false
+	}
+	return !ftc.IsDir()
+}
+
+func (ftc *fileTypeChecker) MakeFile() error {
+	return ftc.mounter.MakeFile(ftc.path)
+}
+
+func (ftc *fileTypeChecker) IsDir() bool {
+	if !ftc.Exists() {
+		return false
+	}
+	pathType, err := ftc.mounter.GetFileType(ftc.path)
+	if err != nil {
+		return false
+	}
+	return string(pathType) == string(v1.HostPathDirectory)
+}
+
+func (ftc *fileTypeChecker) MakeDir() error {
+	return ftc.mounter.MakeDir(ftc.path)
+}
+
+func (ftc *fileTypeChecker) IsBlock() bool {
+	blkDevType, err := ftc.mounter.GetFileType(ftc.path)
+	if err != nil {
+		return false
+	}
+	return string(blkDevType) == string(v1.HostPathBlockDev)
+}
+
+func (ftc *fileTypeChecker) IsChar() bool {
+	charDevType, err := ftc.mounter.GetFileType(ftc.path)
+	if err != nil {
+		return false
+	}
+	return string(charDevType) == string(v1.HostPathCharDev)
+}
+
+func (ftc *fileTypeChecker) IsSocket() bool {
+	socketType, err := ftc.mounter.GetFileType(ftc.path)
+	if err != nil {
+		return false
+	}
+	return string(socketType) == string(v1.HostPathSocket)
+}
+
+func (ftc *fileTypeChecker) GetPath() string {
+	return ftc.path
+}
+
+func newFileTypeChecker(path string, mounter mount.Interface) hostPathTypeChecker {
+	return &fileTypeChecker{path: path, mounter: mounter}
+}
+
+// checkType checks whether the given path is the exact pathType
+func checkType(path string, pathType *v1.HostPathType, mounter mount.Interface) error {
+	return checkTypeInternal(newFileTypeChecker(path, mounter), pathType)
+}
+
+func checkTypeInternal(ftc hostPathTypeChecker, pathType *v1.HostPathType) error {
+	switch *pathType {
+	case v1.HostPathDirectoryOrCreate:
+		if !ftc.Exists() {
+			return ftc.MakeDir()
+		}
+		fallthrough
+	case v1.HostPathDirectory:
+		if !ftc.IsDir() {
+			return fmt.Errorf("hostPath type check failed: %s is not a directory", ftc.GetPath())
+		}
+	case v1.HostPathFileOrCreate:
+		if !ftc.Exists() {
+			return ftc.MakeFile()
+		}
+		fallthrough
+	case v1.HostPathFile:
+		if !ftc.IsFile() {
+			return fmt.Errorf("hostPath type check failed: %s is not a file", ftc.GetPath())
+		}
+	case v1.HostPathSocket:
+		if !ftc.IsSocket() {
+			return fmt.Errorf("hostPath type check failed: %s is not a socket file", ftc.GetPath())
+		}
+	case v1.HostPathCharDev:
+		if !ftc.IsChar() {
+			return fmt.Errorf("hostPath type check failed: %s is not a character device", ftc.GetPath())
+		}
+	case v1.HostPathBlockDev:
+		if !ftc.IsBlock() {
+			return fmt.Errorf("hostPath type check failed: %s is not a block device", ftc.GetPath())
+		}
+	default:
+		return fmt.Errorf("%s is an invalid volume type", *pathType)
+	}
+
+	return nil
+}

vendor/k8s.io/kubernetes/pkg/volume/host_path/host_path_test.go

@@ -0,0 +1,662 @@
+/*
+Copyright 2014 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 host_path
+
+import (
+	"fmt"
+	"os"
+	"testing"
+
+	"k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
+	"k8s.io/apimachinery/pkg/util/uuid"
+	"k8s.io/client-go/kubernetes/fake"
+	utilfile "k8s.io/kubernetes/pkg/util/file"
+	utilmount "k8s.io/kubernetes/pkg/util/mount"
+	"k8s.io/kubernetes/pkg/volume"
+	volumetest "k8s.io/kubernetes/pkg/volume/testing"
+)
+
+func newHostPathType(pathType string) *v1.HostPathType {
+	hostPathType := new(v1.HostPathType)
+	*hostPathType = v1.HostPathType(pathType)
+	return hostPathType
+}
+
+func newHostPathTypeList(pathType ...string) []*v1.HostPathType {
+	typeList := []*v1.HostPathType{}
+	for _, ele := range pathType {
+		typeList = append(typeList, newHostPathType(ele))
+	}
+
+	return typeList
+}
+
+func TestCanSupport(t *testing.T) {
+	plugMgr := volume.VolumePluginMgr{}
+	plugMgr.InitPlugins(ProbeVolumePlugins(volume.VolumeConfig{}), nil /* prober */, volumetest.NewFakeVolumeHost("fake", nil, nil))
+
+	plug, err := plugMgr.FindPluginByName("kubernetes.io/host-path")
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	if plug.GetPluginName() != "kubernetes.io/host-path" {
+		t.Errorf("Wrong name: %s", plug.GetPluginName())
+	}
+	if !plug.CanSupport(&volume.Spec{Volume: &v1.Volume{VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{}}}}) {
+		t.Errorf("Expected true")
+	}
+	if !plug.CanSupport(&volume.Spec{PersistentVolume: &v1.PersistentVolume{Spec: v1.PersistentVolumeSpec{PersistentVolumeSource: v1.PersistentVolumeSource{HostPath: &v1.HostPathVolumeSource{}}}}}) {
+		t.Errorf("Expected true")
+	}
+	if plug.CanSupport(&volume.Spec{Volume: &v1.Volume{VolumeSource: v1.VolumeSource{}}}) {
+		t.Errorf("Expected false")
+	}
+}
+
+func TestGetAccessModes(t *testing.T) {
+	plugMgr := volume.VolumePluginMgr{}
+	plugMgr.InitPlugins(ProbeVolumePlugins(volume.VolumeConfig{}), nil /* prober */, volumetest.NewFakeVolumeHost("/tmp/fake", nil, nil))
+
+	plug, err := plugMgr.FindPersistentPluginByName("kubernetes.io/host-path")
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	if len(plug.GetAccessModes()) != 1 || plug.GetAccessModes()[0] != v1.ReadWriteOnce {
+		t.Errorf("Expected %s PersistentVolumeAccessMode", v1.ReadWriteOnce)
+	}
+}
+
+func TestRecycler(t *testing.T) {
+	plugMgr := volume.VolumePluginMgr{}
+	pluginHost := volumetest.NewFakeVolumeHost("/tmp/fake", nil, nil)
+	plugMgr.InitPlugins([]volume.VolumePlugin{&hostPathPlugin{nil, volume.VolumeConfig{}}}, nil, pluginHost)
+
+	spec := &volume.Spec{PersistentVolume: &v1.PersistentVolume{Spec: v1.PersistentVolumeSpec{PersistentVolumeSource: v1.PersistentVolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/foo"}}}}}
+	_, err := plugMgr.FindRecyclablePluginBySpec(spec)
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+}
+
+func TestDeleter(t *testing.T) {
+	// Deleter has a hard-coded regex for "/tmp".
+	tempPath := fmt.Sprintf("/tmp/hostpath/%s", uuid.NewUUID())
+	defer os.RemoveAll(tempPath)
+	err := os.MkdirAll(tempPath, 0750)
+	if err != nil {
+		t.Fatalf("Failed to create tmp directory for deleter: %v", err)
+	}
+
+	plugMgr := volume.VolumePluginMgr{}
+	plugMgr.InitPlugins(ProbeVolumePlugins(volume.VolumeConfig{}), nil /* prober */, volumetest.NewFakeVolumeHost("/tmp/fake", nil, nil))
+
+	spec := &volume.Spec{PersistentVolume: &v1.PersistentVolume{Spec: v1.PersistentVolumeSpec{PersistentVolumeSource: v1.PersistentVolumeSource{HostPath: &v1.HostPathVolumeSource{Path: tempPath}}}}}
+	plug, err := plugMgr.FindDeletablePluginBySpec(spec)
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	deleter, err := plug.NewDeleter(spec)
+	if err != nil {
+		t.Errorf("Failed to make a new Deleter: %v", err)
+	}
+	if deleter.GetPath() != tempPath {
+		t.Errorf("Expected %s but got %s", tempPath, deleter.GetPath())
+	}
+	if err := deleter.Delete(); err != nil {
+		t.Errorf("Mock Recycler expected to return nil but got %s", err)
+	}
+	if exists, _ := utilfile.FileExists(tempPath); exists {
+		t.Errorf("Temp path expected to be deleted, but was found at %s", tempPath)
+	}
+}
+
+func TestDeleterTempDir(t *testing.T) {
+	tests := map[string]struct {
+		expectedFailure bool
+		path            string
+	}{
+		"just-tmp": {true, "/tmp"},
+		"not-tmp":  {true, "/nottmp"},
+		"good-tmp": {false, "/tmp/scratch"},
+	}
+
+	for name, test := range tests {
+		plugMgr := volume.VolumePluginMgr{}
+		plugMgr.InitPlugins(ProbeVolumePlugins(volume.VolumeConfig{}), nil /* prober */, volumetest.NewFakeVolumeHost("/tmp/fake", nil, nil))
+		spec := &volume.Spec{PersistentVolume: &v1.PersistentVolume{Spec: v1.PersistentVolumeSpec{PersistentVolumeSource: v1.PersistentVolumeSource{HostPath: &v1.HostPathVolumeSource{Path: test.path}}}}}
+		plug, _ := plugMgr.FindDeletablePluginBySpec(spec)
+		deleter, _ := plug.NewDeleter(spec)
+		err := deleter.Delete()
+		if err == nil && test.expectedFailure {
+			t.Errorf("Expected failure for test '%s' but got nil err", name)
+		}
+		if err != nil && !test.expectedFailure {
+			t.Errorf("Unexpected failure for test '%s': %v", name, err)
+		}
+	}
+}
+
+func TestProvisioner(t *testing.T) {
+	tempPath := fmt.Sprintf("/tmp/hostpath/%s", uuid.NewUUID())
+	defer os.RemoveAll(tempPath)
+	err := os.MkdirAll(tempPath, 0750)
+	if err != nil {
+		t.Errorf("Failed to create tempPath %s error:%v", tempPath, err)
+	}
+	plugMgr := volume.VolumePluginMgr{}
+	plugMgr.InitPlugins(ProbeVolumePlugins(volume.VolumeConfig{ProvisioningEnabled: true}),
+		nil,
+		volumetest.NewFakeVolumeHost("/tmp/fake", nil, nil))
+	spec := &volume.Spec{PersistentVolume: &v1.PersistentVolume{Spec: v1.PersistentVolumeSpec{PersistentVolumeSource: v1.PersistentVolumeSource{HostPath: &v1.HostPathVolumeSource{Path: tempPath}}}}}
+	plug, err := plugMgr.FindCreatablePluginBySpec(spec)
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+	options := volume.VolumeOptions{
+		PVC: volumetest.CreateTestPVC("1Gi", []v1.PersistentVolumeAccessMode{v1.ReadWriteOnce}),
+		PersistentVolumeReclaimPolicy: v1.PersistentVolumeReclaimDelete,
+	}
+	creater, err := plug.NewProvisioner(options)
+	if err != nil {
+		t.Errorf("Failed to make a new Provisioner: %v", err)
+	}
+	pv, err := creater.Provision()
+	if err != nil {
+		t.Errorf("Unexpected error creating volume: %v", err)
+	}
+	if pv.Spec.HostPath.Path == "" {
+		t.Errorf("Expected pv.Spec.HostPath.Path to not be empty: %#v", pv)
+	}
+	expectedCapacity := resource.NewQuantity(1*1024*1024*1024, resource.BinarySI)
+	actualCapacity := pv.Spec.Capacity[v1.ResourceStorage]
+	expectedAmt := expectedCapacity.Value()
+	actualAmt := actualCapacity.Value()
+	if expectedAmt != actualAmt {
+		t.Errorf("Expected capacity %+v but got %+v", expectedAmt, actualAmt)
+	}
+
+	if pv.Spec.PersistentVolumeReclaimPolicy != v1.PersistentVolumeReclaimDelete {
+		t.Errorf("Expected reclaim policy %+v but got %+v", v1.PersistentVolumeReclaimDelete, pv.Spec.PersistentVolumeReclaimPolicy)
+	}
+
+	os.RemoveAll(pv.Spec.HostPath.Path)
+}
+
+func TestInvalidHostPath(t *testing.T) {
+	plugMgr := volume.VolumePluginMgr{}
+	plugMgr.InitPlugins(ProbeVolumePlugins(volume.VolumeConfig{}), nil /* prober */, volumetest.NewFakeVolumeHost("fake", nil, nil))
+
+	plug, err := plugMgr.FindPluginByName(hostPathPluginName)
+	if err != nil {
+		t.Fatalf("Unable to find plugin %s by name: %v", hostPathPluginName, err)
+	}
+	spec := &v1.Volume{
+		Name:         "vol1",
+		VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: "/no/backsteps/allowed/.."}},
+	}
+	pod := &v1.Pod{ObjectMeta: metav1.ObjectMeta{UID: types.UID("poduid")}}
+	mounter, err := plug.NewMounter(volume.NewSpecFromVolume(spec), pod, volume.VolumeOptions{})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	err = mounter.SetUp(nil)
+	expectedMsg := "invalid HostPath `/no/backsteps/allowed/..`: must not contain '..'"
+	if err.Error() != expectedMsg {
+		t.Fatalf("expected error `%s` but got `%s`", expectedMsg, err)
+	}
+}
+
+func TestPlugin(t *testing.T) {
+	plugMgr := volume.VolumePluginMgr{}
+	plugMgr.InitPlugins(ProbeVolumePlugins(volume.VolumeConfig{}), nil /* prober */, volumetest.NewFakeVolumeHost("fake", nil, nil))
+
+	plug, err := plugMgr.FindPluginByName("kubernetes.io/host-path")
+	if err != nil {
+		t.Errorf("Can't find the plugin by name")
+	}
+
+	volPath := "/tmp/vol1"
+	spec := &v1.Volume{
+		Name:         "vol1",
+		VolumeSource: v1.VolumeSource{HostPath: &v1.HostPathVolumeSource{Path: volPath, Type: newHostPathType(string(v1.HostPathDirectoryOrCreate))}},
+	}
+	pod := &v1.Pod{ObjectMeta: metav1.ObjectMeta{UID: types.UID("poduid")}}
+	defer os.RemoveAll(volPath)
+	mounter, err := plug.NewMounter(volume.NewSpecFromVolume(spec), pod, volume.VolumeOptions{})
+	if err != nil {
+		t.Errorf("Failed to make a new Mounter: %v", err)
+	}
+	if mounter == nil {
+		t.Fatalf("Got a nil Mounter")
+	}
+
+	path := mounter.GetPath()
+	if path != volPath {
+		t.Errorf("Got unexpected path: %s", path)
+	}
+
+	if err := mounter.SetUp(nil); err != nil {
+		t.Errorf("Expected success, got: %v", err)
+	}
+
+	unmounter, err := plug.NewUnmounter("vol1", types.UID("poduid"))
+	if err != nil {
+		t.Errorf("Failed to make a new Unmounter: %v", err)
+	}
+	if unmounter == nil {
+		t.Fatalf("Got a nil Unmounter")
+	}
+
+	if err := unmounter.TearDown(); err != nil {
+		t.Errorf("Expected success, got: %v", err)
+	}
+}
+
+func TestPersistentClaimReadOnlyFlag(t *testing.T) {
+	pv := &v1.PersistentVolume{
+		ObjectMeta: metav1.ObjectMeta{
+			Name: "pvA",
+		},
+		Spec: v1.PersistentVolumeSpec{
+			PersistentVolumeSource: v1.PersistentVolumeSource{
+				HostPath: &v1.HostPathVolumeSource{Path: "foo", Type: newHostPathType(string(v1.HostPathDirectoryOrCreate))},
+			},
+			ClaimRef: &v1.ObjectReference{
+				Name: "claimA",
+			},
+		},
+	}
+	defer os.RemoveAll("foo")
+
+	claim := &v1.PersistentVolumeClaim{
+		ObjectMeta: metav1.ObjectMeta{
+			Name:      "claimA",
+			Namespace: "nsA",
+		},
+		Spec: v1.PersistentVolumeClaimSpec{
+			VolumeName: "pvA",
+		},
+		Status: v1.PersistentVolumeClaimStatus{
+			Phase: v1.ClaimBound,
+		},
+	}
+
+	client := fake.NewSimpleClientset(pv, claim)
+
+	plugMgr := volume.VolumePluginMgr{}
+	plugMgr.InitPlugins(ProbeVolumePlugins(volume.VolumeConfig{}), nil /* prober */, volumetest.NewFakeVolumeHost("/tmp/fake", client, nil))
+	plug, _ := plugMgr.FindPluginByName(hostPathPluginName)
+
+	// readOnly bool is supplied by persistent-claim volume source when its mounter creates other volumes
+	spec := volume.NewSpecFromPersistentVolume(pv, true)
+	pod := &v1.Pod{ObjectMeta: metav1.ObjectMeta{UID: types.UID("poduid")}}
+	mounter, _ := plug.NewMounter(spec, pod, volume.VolumeOptions{})
+	if mounter == nil {
+		t.Fatalf("Got a nil Mounter")
+	}
+
+	if !mounter.GetAttributes().ReadOnly {
+		t.Errorf("Expected true for mounter.IsReadOnly")
+	}
+}
+
+type fakeFileTypeChecker struct {
+	desiredType string
+}
+
+func (fftc *fakeFileTypeChecker) Mount(source string, target string, fstype string, options []string) error {
+	return nil
+}
+
+func (fftc *fakeFileTypeChecker) Unmount(target string) error {
+	return nil
+}
+
+func (fftc *fakeFileTypeChecker) List() ([]utilmount.MountPoint, error) {
+	return nil, nil
+}
+func (fftc *fakeFileTypeChecker) IsMountPointMatch(mp utilmount.MountPoint, dir string) bool {
+	return false
+}
+
+func (fftc *fakeFileTypeChecker) IsNotMountPoint(file string) (bool, error) {
+	return false, nil
+}
+
+func (fftc *fakeFileTypeChecker) IsLikelyNotMountPoint(file string) (bool, error) {
+	return false, nil
+}
+
+func (fftc *fakeFileTypeChecker) DeviceOpened(pathname string) (bool, error) {
+	return false, nil
+}
+func (fftc *fakeFileTypeChecker) PathIsDevice(pathname string) (bool, error) {
+	return false, nil
+}
+
+func (fftc *fakeFileTypeChecker) GetDeviceNameFromMount(mountPath, pluginDir string) (string, error) {
+	return "fake", nil
+}
+
+func (fftc *fakeFileTypeChecker) MakeRShared(path string) error {
+	return nil
+}
+
+func (fftc *fakeFileTypeChecker) MakeFile(pathname string) error {
+	return nil
+}
+
+func (fftc *fakeFileTypeChecker) MakeDir(pathname string) error {
+	return nil
+}
+
+func (fftc *fakeFileTypeChecker) ExistsPath(pathname string) bool {
+	return true
+}
+
+func (fftc *fakeFileTypeChecker) GetFileType(_ string) (utilmount.FileType, error) {
+	return utilmount.FileType(fftc.desiredType), nil
+}
+
+func setUp() error {
+	err := os.MkdirAll("/tmp/ExistingFolder", os.FileMode(0755))
+	if err != nil {
+		return err
+	}
+
+	f, err := os.OpenFile("/tmp/ExistingFolder/foo", os.O_CREATE, os.FileMode(0644))
+	defer f.Close()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func tearDown() {
+	os.RemoveAll("/tmp/ExistingFolder")
+}
+
+func TestOSFileTypeChecker(t *testing.T) {
+	err := setUp()
+	if err != nil {
+		t.Error(err)
+	}
+	defer tearDown()
+	testCases := []struct {
+		name        string
+		path        string
+		desiredType string
+		isDir       bool
+		isFile      bool
+		isSocket    bool
+		isBlock     bool
+		isChar      bool
+	}{
+		{
+			name:        "Existing Folder",
+			path:        "/tmp/ExistingFolder",
+			desiredType: string(utilmount.FileTypeDirectory),
+			isDir:       true,
+		},
+		{
+			name:        "Existing File",
+			path:        "/tmp/ExistingFolder/foo",
+			desiredType: string(utilmount.FileTypeFile),
+			isFile:      true,
+		},
+		{
+			name:        "Existing Socket File",
+			path:        "/tmp/ExistingFolder/foo",
+			desiredType: string(v1.HostPathSocket),
+			isSocket:    true,
+		},
+		{
+			name:        "Existing Character Device",
+			path:        "/tmp/ExistingFolder/foo",
+			desiredType: string(v1.HostPathCharDev),
+			isChar:      true,
+		},
+		{
+			name:        "Existing Block Device",
+			path:        "/tmp/ExistingFolder/foo",
+			desiredType: string(v1.HostPathBlockDev),
+			isBlock:     true,
+		},
+	}
+
+	for i, tc := range testCases {
+		fakeFTC := &fakeFileTypeChecker{desiredType: tc.desiredType}
+		oftc := newFileTypeChecker(tc.path, fakeFTC)
+
+		path := oftc.GetPath()
+		if path != tc.path {
+			t.Errorf("[%d: %q] got unexpected path: %s", i, tc.name, path)
+		}
+
+		exist := oftc.Exists()
+		if !exist {
+			t.Errorf("[%d: %q] path: %s does not exist", i, tc.name, path)
+		}
+
+		if tc.isDir {
+			if !oftc.IsDir() {
+				t.Errorf("[%d: %q] expected folder, got unexpected: %s", i, tc.name, path)
+			}
+			if oftc.IsFile() {
+				t.Errorf("[%d: %q] expected folder, got unexpected file: %s", i, tc.name, path)
+			}
+			if oftc.IsSocket() {
+				t.Errorf("[%d: %q] expected folder, got unexpected socket file: %s", i, tc.name, path)
+			}
+			if oftc.IsBlock() {
+				t.Errorf("[%d: %q] expected folder, got unexpected block device: %s", i, tc.name, path)
+			}
+			if oftc.IsChar() {
+				t.Errorf("[%d: %q] expected folder, got unexpected character device: %s", i, tc.name, path)
+			}
+		}
+
+		if tc.isFile {
+			if !oftc.IsFile() {
+				t.Errorf("[%d: %q] expected file, got unexpected: %s", i, tc.name, path)
+			}
+			if oftc.IsDir() {
+				t.Errorf("[%d: %q] expected file, got unexpected folder: %s", i, tc.name, path)
+			}
+			if oftc.IsSocket() {
+				t.Errorf("[%d: %q] expected file, got unexpected socket file: %s", i, tc.name, path)
+			}
+			if oftc.IsBlock() {
+				t.Errorf("[%d: %q] expected file, got unexpected block device: %s", i, tc.name, path)
+			}
+			if oftc.IsChar() {
+				t.Errorf("[%d: %q] expected file, got unexpected character device: %s", i, tc.name, path)
+			}
+		}
+
+		if tc.isSocket {
+			if !oftc.IsSocket() {
+				t.Errorf("[%d: %q] expected socket file, got unexpected: %s", i, tc.name, path)
+			}
+			if oftc.IsDir() {
+				t.Errorf("[%d: %q] expected socket file, got unexpected folder: %s", i, tc.name, path)
+			}
+			if !oftc.IsFile() {
+				t.Errorf("[%d: %q] expected socket file, got unexpected file: %s", i, tc.name, path)
+			}
+			if oftc.IsBlock() {
+				t.Errorf("[%d: %q] expected socket file, got unexpected block device: %s", i, tc.name, path)
+			}
+			if oftc.IsChar() {
+				t.Errorf("[%d: %q] expected socket file, got unexpected character device: %s", i, tc.name, path)
+			}
+		}
+
+		if tc.isChar {
+			if !oftc.IsChar() {
+				t.Errorf("[%d: %q] expected character device, got unexpected: %s", i, tc.name, path)
+			}
+			if oftc.IsDir() {
+				t.Errorf("[%d: %q] expected character device, got unexpected folder: %s", i, tc.name, path)
+			}
+			if !oftc.IsFile() {
+				t.Errorf("[%d: %q] expected character device, got unexpected file: %s", i, tc.name, path)
+			}
+			if oftc.IsSocket() {
+				t.Errorf("[%d: %q] expected character device, got unexpected socket file: %s", i, tc.name, path)
+			}
+			if oftc.IsBlock() {
+				t.Errorf("[%d: %q] expected character device, got unexpected block device: %s", i, tc.name, path)
+			}
+		}
+
+		if tc.isBlock {
+			if !oftc.IsBlock() {
+				t.Errorf("[%d: %q] expected block device, got unexpected: %s", i, tc.name, path)
+			}
+			if oftc.IsDir() {
+				t.Errorf("[%d: %q] expected block device, got unexpected folder: %s", i, tc.name, path)
+			}
+			if !oftc.IsFile() {
+				t.Errorf("[%d: %q] expected block device, got unexpected file: %s", i, tc.name, path)
+			}
+			if oftc.IsSocket() {
+				t.Errorf("[%d: %q] expected block device, got unexpected socket file: %s", i, tc.name, path)
+			}
+			if oftc.IsChar() {
+				t.Errorf("[%d: %q] expected block device, got unexpected character device: %s", i, tc.name, path)
+			}
+		}
+	}
+
+}
+
+type fakeHostPathTypeChecker struct {
+	name            string
+	path            string
+	exists          bool
+	isDir           bool
+	isFile          bool
+	isSocket        bool
+	isBlock         bool
+	isChar          bool
+	validpathType   []*v1.HostPathType
+	invalidpathType []*v1.HostPathType
+}
+
+func (ftc *fakeHostPathTypeChecker) MakeFile() error { return nil }
+func (ftc *fakeHostPathTypeChecker) MakeDir() error  { return nil }
+func (ftc *fakeHostPathTypeChecker) Exists() bool    { return ftc.exists }
+func (ftc *fakeHostPathTypeChecker) IsFile() bool    { return ftc.isFile }
+func (ftc *fakeHostPathTypeChecker) IsDir() bool     { return ftc.isDir }
+func (ftc *fakeHostPathTypeChecker) IsBlock() bool   { return ftc.isBlock }
+func (ftc *fakeHostPathTypeChecker) IsChar() bool    { return ftc.isChar }
+func (ftc *fakeHostPathTypeChecker) IsSocket() bool  { return ftc.isSocket }
+func (ftc *fakeHostPathTypeChecker) GetPath() string { return ftc.path }
+
+func TestHostPathTypeCheckerInternal(t *testing.T) {
+	testCases := []fakeHostPathTypeChecker{
+		{
+			name:          "Existing Folder",
+			path:          "/existingFolder",
+			isDir:         true,
+			exists:        true,
+			validpathType: newHostPathTypeList(string(v1.HostPathDirectoryOrCreate), string(v1.HostPathDirectory)),
+			invalidpathType: newHostPathTypeList(string(v1.HostPathFileOrCreate), string(v1.HostPathFile),
+				string(v1.HostPathSocket), string(v1.HostPathCharDev), string(v1.HostPathBlockDev)),
+		},
+		{
+			name:          "New Folder",
+			path:          "/newFolder",
+			isDir:         false,
+			exists:        false,
+			validpathType: newHostPathTypeList(string(v1.HostPathDirectoryOrCreate)),
+			invalidpathType: newHostPathTypeList(string(v1.HostPathDirectory), string(v1.HostPathFile),
+				string(v1.HostPathSocket), string(v1.HostPathCharDev), string(v1.HostPathBlockDev)),
+		},
+		{
+			name:          "Existing File",
+			path:          "/existingFile",
+			isFile:        true,
+			exists:        true,
+			validpathType: newHostPathTypeList(string(v1.HostPathFileOrCreate), string(v1.HostPathFile)),
+			invalidpathType: newHostPathTypeList(string(v1.HostPathDirectoryOrCreate), string(v1.HostPathDirectory),
+				string(v1.HostPathSocket), string(v1.HostPathCharDev), string(v1.HostPathBlockDev)),
+		},
+		{
+			name:          "New File",
+			path:          "/newFile",
+			isFile:        false,
+			exists:        false,
+			validpathType: newHostPathTypeList(string(v1.HostPathFileOrCreate)),
+			invalidpathType: newHostPathTypeList(string(v1.HostPathDirectory),
+				string(v1.HostPathSocket), string(v1.HostPathCharDev), string(v1.HostPathBlockDev)),
+		},
+		{
+			name:          "Existing Socket",
+			path:          "/existing.socket",
+			isSocket:      true,
+			isFile:        true,
+			exists:        true,
+			validpathType: newHostPathTypeList(string(v1.HostPathSocket), string(v1.HostPathFileOrCreate), string(v1.HostPathFile)),
+			invalidpathType: newHostPathTypeList(string(v1.HostPathDirectoryOrCreate), string(v1.HostPathDirectory),
+				string(v1.HostPathCharDev), string(v1.HostPathBlockDev)),
+		},
+		{
+			name:          "Existing Character Device",
+			path:          "/existing.char",
+			isChar:        true,
+			isFile:        true,
+			exists:        true,
+			validpathType: newHostPathTypeList(string(v1.HostPathCharDev), string(v1.HostPathFileOrCreate), string(v1.HostPathFile)),
+			invalidpathType: newHostPathTypeList(string(v1.HostPathDirectoryOrCreate), string(v1.HostPathDirectory),
+				string(v1.HostPathSocket), string(v1.HostPathBlockDev)),
+		},
+		{
+			name:          "Existing Block Device",
+			path:          "/existing.block",
+			isBlock:       true,
+			isFile:        true,
+			exists:        true,
+			validpathType: newHostPathTypeList(string(v1.HostPathBlockDev), string(v1.HostPathFileOrCreate), string(v1.HostPathFile)),
+			invalidpathType: newHostPathTypeList(string(v1.HostPathDirectoryOrCreate), string(v1.HostPathDirectory),
+				string(v1.HostPathSocket), string(v1.HostPathCharDev)),
+		},
+	}
+
+	for i, tc := range testCases {
+		for _, pathType := range tc.validpathType {
+			err := checkTypeInternal(&tc, pathType)
+			if err != nil {
+				t.Errorf("[%d: %q] [%q] expected nil, got %v", i, tc.name, string(*pathType), err)
+			}
+		}
+
+		for _, pathType := range tc.invalidpathType {
+			checkResult := checkTypeInternal(&tc, pathType)
+			if checkResult == nil {
+				t.Errorf("[%d: %q] [%q] expected error, got nil", i, tc.name, string(*pathType))
+			}
+		}
+	}
+
+}