mirror of https://github.com/k3s-io/k3s
277 lines
8.1 KiB
Go
277 lines
8.1 KiB
Go
/*
|
||
Copyright 2014 The Kubernetes Authors All rights reserved.
|
||
|
||
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 empty_dir
|
||
|
||
import (
|
||
"io/ioutil"
|
||
"os"
|
||
"path"
|
||
"testing"
|
||
|
||
"k8s.io/kubernetes/pkg/api"
|
||
"k8s.io/kubernetes/pkg/types"
|
||
"k8s.io/kubernetes/pkg/util/mount"
|
||
"k8s.io/kubernetes/pkg/volume"
|
||
"k8s.io/kubernetes/pkg/volume/util"
|
||
)
|
||
|
||
// Construct an instance of a plugin, by name.
|
||
func makePluginUnderTest(t *testing.T, plugName, basePath string) volume.VolumePlugin {
|
||
plugMgr := volume.VolumePluginMgr{}
|
||
plugMgr.InitPlugins(ProbeVolumePlugins(), volume.NewFakeVolumeHost(basePath, nil, nil))
|
||
|
||
plug, err := plugMgr.FindPluginByName(plugName)
|
||
if err != nil {
|
||
t.Errorf("Can't find the plugin by name")
|
||
}
|
||
return plug
|
||
}
|
||
|
||
func TestCanSupport(t *testing.T) {
|
||
tmpDir, err := ioutil.TempDir(os.TempDir(), "emptydirTest")
|
||
if err != nil {
|
||
t.Fatalf("can't make a temp dir: %v", err)
|
||
}
|
||
defer os.RemoveAll(tmpDir)
|
||
plug := makePluginUnderTest(t, "kubernetes.io/empty-dir", tmpDir)
|
||
|
||
if plug.Name() != "kubernetes.io/empty-dir" {
|
||
t.Errorf("Wrong name: %s", plug.Name())
|
||
}
|
||
if !plug.CanSupport(&volume.Spec{Volume: &api.Volume{VolumeSource: api.VolumeSource{EmptyDir: &api.EmptyDirVolumeSource{}}}}) {
|
||
t.Errorf("Expected true")
|
||
}
|
||
if plug.CanSupport(&volume.Spec{Volume: &api.Volume{VolumeSource: api.VolumeSource{}}}) {
|
||
t.Errorf("Expected false")
|
||
}
|
||
}
|
||
|
||
type fakeMountDetector struct {
|
||
medium storageMedium
|
||
isMount bool
|
||
}
|
||
|
||
func (fake *fakeMountDetector) GetMountMedium(path string) (storageMedium, bool, error) {
|
||
return fake.medium, fake.isMount, nil
|
||
}
|
||
|
||
func TestPluginEmptyRootContext(t *testing.T) {
|
||
doTestPlugin(t, pluginTestConfig{
|
||
medium: api.StorageMediumDefault,
|
||
rootContext: "",
|
||
expectedSetupMounts: 0,
|
||
expectedTeardownMounts: 0})
|
||
}
|
||
|
||
func TestPluginRootContextSet(t *testing.T) {
|
||
if !selinuxEnabled() {
|
||
return
|
||
}
|
||
|
||
doTestPlugin(t, pluginTestConfig{
|
||
medium: api.StorageMediumDefault,
|
||
rootContext: "user:role:type:range",
|
||
expectedSELinuxContext: "user:role:type:range",
|
||
expectedSetupMounts: 0,
|
||
expectedTeardownMounts: 0})
|
||
}
|
||
|
||
func TestPluginTmpfs(t *testing.T) {
|
||
if !selinuxEnabled() {
|
||
return
|
||
}
|
||
|
||
doTestPlugin(t, pluginTestConfig{
|
||
medium: api.StorageMediumMemory,
|
||
rootContext: "user:role:type:range",
|
||
expectedSELinuxContext: "user:role:type:range",
|
||
expectedSetupMounts: 1,
|
||
shouldBeMountedBeforeTeardown: true,
|
||
expectedTeardownMounts: 1})
|
||
}
|
||
|
||
type pluginTestConfig struct {
|
||
medium api.StorageMedium
|
||
rootContext string
|
||
SELinuxOptions *api.SELinuxOptions
|
||
idempotent bool
|
||
expectedSELinuxContext string
|
||
expectedSetupMounts int
|
||
shouldBeMountedBeforeTeardown bool
|
||
expectedTeardownMounts int
|
||
}
|
||
|
||
// doTestPlugin sets up a volume and tears it back down.
|
||
func doTestPlugin(t *testing.T, config pluginTestConfig) {
|
||
basePath, err := ioutil.TempDir(os.TempDir(), "emptydir_volume_test")
|
||
if err != nil {
|
||
t.Fatalf("can't make a temp rootdir: %v", err)
|
||
}
|
||
defer os.RemoveAll(basePath)
|
||
|
||
var (
|
||
volumePath = path.Join(basePath, "pods/poduid/volumes/kubernetes.io~empty-dir/test-volume")
|
||
metadataDir = path.Join(basePath, "pods/poduid/plugins/kubernetes.io~empty-dir/test-volume")
|
||
|
||
plug = makePluginUnderTest(t, "kubernetes.io/empty-dir", basePath)
|
||
volumeName = "test-volume"
|
||
spec = &api.Volume{
|
||
Name: volumeName,
|
||
VolumeSource: api.VolumeSource{EmptyDir: &api.EmptyDirVolumeSource{Medium: config.medium}},
|
||
}
|
||
|
||
mounter = mount.FakeMounter{}
|
||
mountDetector = fakeMountDetector{}
|
||
pod = &api.Pod{ObjectMeta: api.ObjectMeta{UID: types.UID("poduid")}}
|
||
)
|
||
|
||
// Set up the SELinux options on the pod
|
||
if config.SELinuxOptions != nil {
|
||
pod.Spec = api.PodSpec{
|
||
Containers: []api.Container{
|
||
{
|
||
SecurityContext: &api.SecurityContext{
|
||
SELinuxOptions: config.SELinuxOptions,
|
||
},
|
||
VolumeMounts: []api.VolumeMount{
|
||
{
|
||
Name: volumeName,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
}
|
||
}
|
||
|
||
if config.idempotent {
|
||
mounter.MountPoints = []mount.MountPoint{
|
||
{
|
||
Path: volumePath,
|
||
},
|
||
}
|
||
util.SetReady(metadataDir)
|
||
}
|
||
|
||
builder, err := plug.(*emptyDirPlugin).newBuilderInternal(volume.NewSpecFromVolume(spec),
|
||
pod,
|
||
&mounter,
|
||
&mountDetector,
|
||
volume.VolumeOptions{RootContext: config.rootContext})
|
||
if err != nil {
|
||
t.Errorf("Failed to make a new Builder: %v", err)
|
||
}
|
||
if builder == nil {
|
||
t.Errorf("Got a nil Builder")
|
||
}
|
||
|
||
volPath := builder.GetPath()
|
||
if volPath != volumePath {
|
||
t.Errorf("Got unexpected path: %s", volPath)
|
||
}
|
||
|
||
if err := builder.SetUp(); err != nil {
|
||
t.Errorf("Expected success, got: %v", err)
|
||
}
|
||
|
||
// Stat the directory and check the permission bits
|
||
fileinfo, err := os.Stat(volPath)
|
||
if !config.idempotent {
|
||
if err != nil {
|
||
if os.IsNotExist(err) {
|
||
t.Errorf("SetUp() failed, volume path not created: %s", volPath)
|
||
} else {
|
||
t.Errorf("SetUp() failed: %v", err)
|
||
}
|
||
}
|
||
if e, a := perm, fileinfo.Mode().Perm(); e != a {
|
||
t.Errorf("Unexpected file mode for %v: expected: %v, got: %v", volPath, e, a)
|
||
}
|
||
} else if err == nil {
|
||
// If this test is for idempotency and we were able
|
||
// to stat the volume path, it's an error.
|
||
t.Errorf("Volume directory was created unexpectedly")
|
||
}
|
||
|
||
// Check the number of mounts performed during setup
|
||
if e, a := config.expectedSetupMounts, len(mounter.Log); e != a {
|
||
t.Errorf("Expected %v mounter calls during setup, got %v", e, a)
|
||
} else if config.expectedSetupMounts == 1 &&
|
||
(mounter.Log[0].Action != mount.FakeActionMount || mounter.Log[0].FSType != "tmpfs") {
|
||
t.Errorf("Unexpected mounter action during setup: %#v", mounter.Log[0])
|
||
}
|
||
mounter.ResetLog()
|
||
|
||
// Make a cleaner for the volume
|
||
teardownMedium := mediumUnknown
|
||
if config.medium == api.StorageMediumMemory {
|
||
teardownMedium = mediumMemory
|
||
}
|
||
cleanerMountDetector := &fakeMountDetector{medium: teardownMedium, isMount: config.shouldBeMountedBeforeTeardown}
|
||
cleaner, err := plug.(*emptyDirPlugin).newCleanerInternal(volumeName, types.UID("poduid"), &mounter, cleanerMountDetector)
|
||
if err != nil {
|
||
t.Errorf("Failed to make a new Cleaner: %v", err)
|
||
}
|
||
if cleaner == nil {
|
||
t.Errorf("Got a nil Cleaner")
|
||
}
|
||
|
||
// Tear down the volume
|
||
if err := cleaner.TearDown(); err != nil {
|
||
t.Errorf("Expected success, got: %v", err)
|
||
}
|
||
if _, err := os.Stat(volPath); err == nil {
|
||
t.Errorf("TearDown() failed, volume path still exists: %s", volPath)
|
||
} else if !os.IsNotExist(err) {
|
||
t.Errorf("SetUp() failed: %v", err)
|
||
}
|
||
|
||
// Check the number of mounter calls during tardown
|
||
if e, a := config.expectedTeardownMounts, len(mounter.Log); e != a {
|
||
t.Errorf("Expected %v mounter calls during teardown, got %v", e, a)
|
||
} else if config.expectedTeardownMounts == 1 && mounter.Log[0].Action != mount.FakeActionUnmount {
|
||
t.Errorf("Unexpected mounter action during teardown: %#v", mounter.Log[0])
|
||
}
|
||
mounter.ResetLog()
|
||
}
|
||
|
||
func TestPluginBackCompat(t *testing.T) {
|
||
basePath, err := ioutil.TempDir(os.TempDir(), "emptydirTest")
|
||
if err != nil {
|
||
t.Fatalf("can't make a temp dir： %v", err)
|
||
}
|
||
defer os.RemoveAll(basePath)
|
||
|
||
plug := makePluginUnderTest(t, "kubernetes.io/empty-dir", basePath)
|
||
|
||
spec := &api.Volume{
|
||
Name: "vol1",
|
||
}
|
||
pod := &api.Pod{ObjectMeta: api.ObjectMeta{UID: types.UID("poduid")}}
|
||
builder, err := plug.NewBuilder(volume.NewSpecFromVolume(spec), pod, volume.VolumeOptions{RootContext: ""})
|
||
if err != nil {
|
||
t.Errorf("Failed to make a new Builder: %v", err)
|
||
}
|
||
if builder == nil {
|
||
t.Errorf("Got a nil Builder")
|
||
}
|
||
|
||
volPath := builder.GetPath()
|
||
if volPath != path.Join(basePath, "pods/poduid/volumes/kubernetes.io~empty-dir/vol1") {
|
||
t.Errorf("Got unexpected path: %s", volPath)
|
||
}
|
||
}
|