github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-09-07 20:21:20 +00:00
Code Issues Projects Releases Wiki Activity

Adds support for attaching GCEPersitentDisks

Browse Source 
Adds GCEPersistentDisk volume struct
Adds gce-utils to attach disk to kubelet's VM.
Updates config to give compute-rw to every minion.
Adds GCEPersistentDisk to API
Adds ability to mount attached disks
Generalizes PD and adds tests.
PD now uses an pluggable API interface.
Unit Tests more cleanly separates TearDown and SetUp
Modify boilerplate hook to omit build tags
Adds Mounter interface; mount is now built by OS
TearDown() for PD now detaches disk on final refcount
Un-generalized PD; GCE calls moved to cloudprovider

Address comments.
This commit is contained in:
Danny Jones
2014-08-05 10:58:43 -07:00
committed by Brendan Burns
parent 48a9ed3147
commit 4ec25f3b81
14 changed files with 791 additions and 40 deletions
Download Patch File Download Diff File Expand all files Collapse all files

159
pkg/volume/volume.go
View File

@@ -21,6 +21,7 @@ import (
"io/ioutil"
"os"
"path"
"strconv"
"github.com/GoogleCloudPlatform/kubernetes/pkg/api"
"github.com/golang/glog"
@@ -49,6 +50,22 @@ type Cleaner interface {
TearDown() error
}
type gcePersistentDiskUtil interface {
// Attaches the disk to the kubelet's host machine.
AttachDisk(PD *GCEPersistentDisk) error
// Detaches the disk from the kubelet's host machine.
DetachDisk(PD *GCEPersistentDisk, devicePath string) error
}
// Mounters wrap os/system specific calls to perform mounts.
type mounter interface {
Mount(source string, target string, fstype string, flags uintptr, data string) error
Unmount(target string, flags int) error
// RefCount returns the device path for the source disk of a volume, and
// the number of references to that target disk.
RefCount(vol Interface) (string, int, error)
}
// HostDir volumes represent a bare host directory mount.
// The directory in Path will be directly exposed to the container.
type HostDir struct {
@@ -118,11 +135,128 @@ func createHostDir(volume *api.Volume) *HostDir {
return &HostDir{volume.Source.HostDir.Path}
}
// GCEPersistentDisk volumes are disk resources provided by Google Compute Engine
// that are attached to the kubelet's host machine and exposed to the pod.
type GCEPersistentDisk struct {
Name string
PodID string
RootDir string
// Unique identifier of the PD, used to find the disk resource in the provider.
PDName string
// Filesystem type, optional.
FSType string
// Specifies the partition to mount
Partition string
// Specifies whether the disk will be attached as ReadOnly.
ReadOnly bool
// Utility interface that provides API calls to the provider to attach/detach disks.
util gcePersistentDiskUtil
// Mounter interface that provides system calls to mount the disks.
mounter mounter
}
func (PD *GCEPersistentDisk) GetPath() string {
return path.Join(PD.RootDir, PD.PodID, "volumes", "gce-pd", PD.Name)
}
// Attaches the disk and bind mounts to the volume path.
func (PD *GCEPersistentDisk) SetUp() error {
// TODO: handle failed mounts here.
if _, err := os.Stat(PD.GetPath()); !os.IsNotExist(err) {
return nil
}
err := PD.util.AttachDisk(PD)
if err != nil {
return err
}
flags := uintptr(0)
if PD.ReadOnly {
flags = MOUNT_MS_RDONLY
}
//Perform a bind mount to the full path to allow duplicate mounts of the same PD.
if _, err = os.Stat(PD.GetPath()); os.IsNotExist(err) {
err = os.MkdirAll(PD.GetPath(), 0750)
if err != nil {
return err
}
globalPDPath := makeGlobalPDName(PD.RootDir, PD.PDName, PD.ReadOnly)
err = PD.mounter.Mount(globalPDPath, PD.GetPath(), "", MOUNT_MS_BIND|flags, "")
if err != nil {
os.RemoveAll(PD.GetPath())
return err
}
}
return nil
}
// Unmounts the bind mount, and detaches the disk only if the PD
// resource was the last reference to that disk on the kubelet.
func (PD *GCEPersistentDisk) TearDown() error {
devicePath, refCount, err := PD.mounter.RefCount(PD)
if err != nil {
return err
}
if err := PD.mounter.Unmount(PD.GetPath(), 0); err != nil {
return err
}
refCount--
if err := os.RemoveAll(PD.GetPath()); err != nil {
return err
}
if err != nil {
return err
}
// If refCount is 1, then all bind mounts have been removed, and the
// remaining reference is the global mount. It is safe to detach.
if refCount == 1 {
if err := PD.util.DetachDisk(PD, devicePath); err != nil {
return err
}
}
return nil
}
//TODO(jonesdl) prevent name collisions by using designated pod space as well.
// Ex. (ROOT_DIR)/pods/...
func makeGlobalPDName(rootDir, devName string, readOnly bool) string {
var mode string
if readOnly {
mode = "ro"
} else {
mode = "rw"
}
return path.Join(rootDir, "global", "pd", mode, devName)
}
// createEmptyDir interprets API volume as an EmptyDir.
func createEmptyDir(volume *api.Volume, podID string, rootDir string) *EmptyDir {
return &EmptyDir{volume.Name, podID, rootDir}
}
// Interprets API volume as a PersistentDisk
func createGCEPersistentDisk(volume *api.Volume, podID string, rootDir string) (*GCEPersistentDisk, error) {
PDName := volume.Source.GCEPersistentDisk.PDName
FSType := volume.Source.GCEPersistentDisk.FSType
partition := strconv.Itoa(volume.Source.GCEPersistentDisk.Partition)
if partition == "0" {
partition = ""
}
readOnly := volume.Source.GCEPersistentDisk.ReadOnly
// TODO: move these up into the Kubelet.
util := &GCEDiskUtil{}
mounter := &DiskMounter{}
return &GCEPersistentDisk{
Name: volume.Name,
PodID: podID,
RootDir: rootDir,
PDName: PDName,
FSType: FSType,
Partition: partition,
ReadOnly: readOnly,
util: util,
mounter: mounter}, nil
}
// CreateVolumeBuilder returns a Builder capable of mounting a volume described by an
// *api.Volume, or an error.
func CreateVolumeBuilder(volume *api.Volume, podID string, rootDir string) (Builder, error) {
@@ -133,12 +267,18 @@ func CreateVolumeBuilder(volume *api.Volume, podID string, rootDir string) (Buil
return nil, nil
}
var vol Builder
var err error
// TODO(jonesdl) We should probably not check every pointer and directly
// resolve these types instead.
if source.HostDir != nil {
vol = createHostDir(volume)
} else if source.EmptyDir != nil {
vol = createEmptyDir(volume, podID, rootDir)
} else if source.GCEPersistentDisk != nil {
vol, err = createGCEPersistentDisk(volume, podID, rootDir)
if err != nil {
return nil, err
}
} else {
return nil, ErrUnsupportedVolumeType
}
@@ -150,6 +290,13 @@ func CreateVolumeCleaner(kind string, name string, podID string, rootDir string)
switch kind {
case "empty":
return &EmptyDir{name, podID, rootDir}, nil
case "gce-pd":
return &GCEPersistentDisk{
Name: name,
PodID: podID,
RootDir: rootDir,
util: &GCEDiskUtil{},
mounter: &DiskMounter{}}, nil
default:
return nil, ErrUnsupportedVolumeType
}
@@ -159,10 +306,9 @@ func CreateVolumeCleaner(kind string, name string, podID string, rootDir string)
// presently active and mounted. Returns a map of Cleaner types.
func GetCurrentVolumes(rootDirectory string) map[string]Cleaner {
currentVolumes := make(map[string]Cleaner)
mountPath := rootDirectory
podIDDirs, err := ioutil.ReadDir(mountPath)
podIDDirs, err := ioutil.ReadDir(rootDirectory)
if err != nil {
glog.Errorf("Could not read directory: %s, (%s)", mountPath, err)
glog.Errorf("Could not read directory: %s, (%s)", rootDirectory, err)
}
// Volume information is extracted from the directory structure:
// (ROOT_DIR)/(POD_ID)/volumes/(VOLUME_KIND)/(VOLUME_NAME)
@@ -171,7 +317,10 @@ func GetCurrentVolumes(rootDirectory string) map[string]Cleaner {
continue
}
podID := podIDDir.Name()
podIDPath := path.Join(mountPath, podID, "volumes")
podIDPath := path.Join(rootDirectory, podID, "volumes")
if _, err := os.Stat(podIDPath); os.IsNotExist(err) {
continue
}
volumeKindDirs, err := ioutil.ReadDir(podIDPath)
if err != nil {
glog.Errorf("Could not read directory: %s, (%s)", podIDPath, err)
@@ -189,7 +338,7 @@ func GetCurrentVolumes(rootDirectory string) map[string]Cleaner {
// TODO(thockin) This should instead return a reference to an extant volume object
cleaner, err := CreateVolumeCleaner(volumeKind, volumeName, podID, rootDirectory)
if err != nil {
glog.Errorf("Could not create volume cleaner: %s, (%s)", volumeNameDirs, err)
glog.Errorf("Could not create volume cleaner: %s, (%s)", volumeNameDir.Name(), err)
continue
}
currentVolumes[identifier] = cleaner