mirrors/ceph-csi
1
0
Fork 0
mirror of https://github.com/ceph/ceph-csi.git synced 2025-06-14 18:53:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fresh dep ensure

Browse Source
This commit is contained in:
Mike Cronce
2018-11-26 13:23:56 -05:00
parent 93cb8a04d7
commit 407478ab9a
9016 changed files with 551394 additions and 279685 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
vendor/k8s.io/kubernetes/pkg/volume/scaleio/BUILD generated vendored
View File

@ -18,14 +18,14 @@ go_test(
"//pkg/util/mount:go_default_library",
"//pkg/volume:go_default_library",
"//pkg/volume/testing:go_default_library",
"//staging/src/k8s.io/api/core/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/runtime:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/types:go_default_library",
"//staging/src/k8s.io/client-go/kubernetes/fake:go_default_library",
"//staging/src/k8s.io/client-go/util/testing:go_default_library",
"//vendor/github.com/codedellemc/goscaleio/types/v1:go_default_library",
"//vendor/github.com/golang/glog: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/runtime:go_default_library",
"//vendor/k8s.io/apimachinery/pkg/types:go_default_library",
"//vendor/k8s.io/client-go/kubernetes/fake:go_default_library",
"//vendor/k8s.io/client-go/util/testing:go_default_library",
"//vendor/k8s.io/klog:go_default_library",
],
)
@ -45,14 +45,14 @@ go_library(
"//pkg/util/strings:go_default_library",
"//pkg/volume:go_default_library",
"//pkg/volume/util:go_default_library",
"//staging/src/k8s.io/api/core/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/api/resource:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/apis/meta/v1:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/types:go_default_library",
"//staging/src/k8s.io/apimachinery/pkg/util/uuid:go_default_library",
"//vendor/github.com/codedellemc/goscaleio:go_default_library",
"//vendor/github.com/codedellemc/goscaleio/types/v1:go_default_library",
"//vendor/github.com/golang/glog: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/klog:go_default_library",
],
)

106
vendor/k8s.io/kubernetes/pkg/volume/scaleio/sio_client.go generated vendored
View File

@ -33,7 +33,7 @@ import (
sio "github.com/codedellemc/goscaleio"
siotypes "github.com/codedellemc/goscaleio/types/v1"
"github.com/golang/glog"
"k8s.io/klog"
)
var (
@ -74,7 +74,7 @@ type sioClient struct {
spClient *sio.StoragePool
provisionMode string
sdcPath string
sdcGuid string
sdcGUID string
instanceID string
inited bool
diskRegex *regexp.Regexp
@ -97,7 +97,7 @@ func newSioClient(gateway, username, password string, sslEnabled bool, exec moun
}
r, err := regexp.Compile(`^emc-vol-\w*-\w*$`)
if err != nil {
glog.Error(log("failed to compile regex: %v", err))
klog.Error(log("failed to compile regex: %v", err))
return nil, err
}
client.diskRegex = r
@ -113,10 +113,10 @@ func (c *sioClient) init() error {
if c.inited {
return nil
}
glog.V(4).Infoln(log("initializing scaleio client"))
klog.V(4).Infoln(log("initializing scaleio client"))
client, err := sio.NewClientWithArgs(c.gateway, "", c.insecure, c.certsEnabled)
if err != nil {
glog.Error(log("failed to create client: %v", err))
klog.Error(log("failed to create client: %v", err))
return err
}
c.client = client
@ -127,24 +127,24 @@ func (c *sioClient) init() error {
Username: c.username,
Password: c.password},
); err != nil {
glog.Error(log("client authentication failed: %v", err))
klog.Error(log("client authentication failed: %v", err))
return err
}
// retrieve system
if c.system, err = c.findSystem(c.sysName); err != nil {
glog.Error(log("unable to find system %s: %v", c.sysName, err))
klog.Error(log("unable to find system %s: %v", c.sysName, err))
return err
}
// retrieve protection domain
if c.protectionDomain, err = c.findProtectionDomain(c.pdName); err != nil {
glog.Error(log("unable to find protection domain %s: %v", c.protectionDomain, err))
klog.Error(log("unable to find protection domain %s: %v", c.protectionDomain, err))
return err
}
// retrieve storage pool
if c.storagePool, err = c.findStoragePool(c.spName); err != nil {
glog.Error(log("unable to find storage pool %s: %v", c.storagePool, err))
klog.Error(log("unable to find storage pool %s: %v", c.storagePool, err))
return err
}
c.inited = true
@ -157,7 +157,7 @@ func (c *sioClient) Volumes() ([]*siotypes.Volume, error) {
}
vols, err := c.getVolumes()
if err != nil {
glog.Error(log("failed to retrieve volumes: %v", err))
klog.Error(log("failed to retrieve volumes: %v", err))
return nil, err
}
return vols, nil
@ -170,12 +170,12 @@ func (c *sioClient) Volume(id sioVolumeID) (*siotypes.Volume, error) {
vols, err := c.getVolumesByID(id)
if err != nil {
glog.Error(log("failed to retrieve volume by id: %v", err))
klog.Error(log("failed to retrieve volume by id: %v", err))
return nil, err
}
vol := vols[0]
if vol == nil {
glog.V(4).Info(log("volume not found, id %s", id))
klog.V(4).Info(log("volume not found, id %s", id))
return nil, errors.New("volume not found")
}
return vol, nil
@ -186,20 +186,20 @@ func (c *sioClient) FindVolume(name string) (*siotypes.Volume, error) {
return nil, err
}
glog.V(4).Info(log("searching for volume %s", name))
klog.V(4).Info(log("searching for volume %s", name))
volumes, err := c.getVolumesByName(name)
if err != nil {
glog.Error(log("failed to find volume by name %v", err))
klog.Error(log("failed to find volume by name %v", err))
return nil, err
}
for _, volume := range volumes {
if volume.Name == name {
glog.V(4).Info(log("found volume %s", name))
klog.V(4).Info(log("found volume %s", name))
return volume, nil
}
}
glog.V(4).Info(log("volume not found, name %s", name))
klog.V(4).Info(log("volume not found, name %s", name))
return nil, errors.New("volume not found")
}
@ -215,7 +215,7 @@ func (c *sioClient) CreateVolume(name string, sizeGB int64) (*siotypes.Volume, e
}
createResponse, err := c.client.CreateVolume(params, c.storagePool.Name)
if err != nil {
glog.Error(log("failed to create volume %s: %v", name, err))
klog.Error(log("failed to create volume %s: %v", name, err))
return nil, err
}
return c.Volume(sioVolumeID(createResponse.ID))
@ -225,18 +225,18 @@ func (c *sioClient) CreateVolume(name string, sizeGB int64) (*siotypes.Volume, e
// is true, ScaleIO will allow other SDC to map to that volume.
func (c *sioClient) AttachVolume(id sioVolumeID, multipleMappings bool) error {
if err := c.init(); err != nil {
glog.Error(log("failed to init'd client in attach volume: %v", err))
klog.Error(log("failed to init'd client in attach volume: %v", err))
return err
}
iid, err := c.IID()
if err != nil {
glog.Error(log("failed to get instanceIID for attach volume: %v", err))
klog.Error(log("failed to get instanceIID for attach volume: %v", err))
return err
}
params := &siotypes.MapVolumeSdcParam{
SdcID: iid,
SdcID: iid,
AllowMultipleMappings: strconv.FormatBool(multipleMappings),
AllSdcs: "",
}
@ -244,11 +244,11 @@ func (c *sioClient) AttachVolume(id sioVolumeID, multipleMappings bool) error {
volClient.Volume = &siotypes.Volume{ID: string(id)}
if err := volClient.MapVolumeSdc(params); err != nil {
glog.Error(log("failed to attach volume id %s: %v", id, err))
klog.Error(log("failed to attach volume id %s: %v", id, err))
return err
}
glog.V(4).Info(log("volume %s attached successfully", id))
klog.V(4).Info(log("volume %s attached successfully", id))
return nil
}
@ -301,35 +301,35 @@ func (c *sioClient) IID() (string, error) {
// if instanceID not set, retrieve it
if c.instanceID == "" {
guid, err := c.getGuid()
guid, err := c.getGUID()
if err != nil {
return "", err
}
sdc, err := c.sysClient.FindSdc("SdcGuid", guid)
sdc, err := c.sysClient.FindSdc("SdcGUID", guid)
if err != nil {
glog.Error(log("failed to retrieve sdc info %s", err))
klog.Error(log("failed to retrieve sdc info %s", err))
return "", err
}
c.instanceID = sdc.Sdc.ID
glog.V(4).Info(log("retrieved instanceID %s", c.instanceID))
klog.V(4).Info(log("retrieved instanceID %s", c.instanceID))
}
return c.instanceID, nil
}
// getGuid returns instance GUID, if not set using resource labels
// getGUID returns instance GUID, if not set using resource labels
// it attempts to fallback to using drv_cfg binary
func (c *sioClient) getGuid() (string, error) {
if c.sdcGuid == "" {
glog.V(4).Info(log("sdc guid label not set, falling back to using drv_cfg"))
func (c *sioClient) getGUID() (string, error) {
if c.sdcGUID == "" {
klog.V(4).Info(log("sdc guid label not set, falling back to using drv_cfg"))
cmd := c.getSdcCmd()
output, err := c.exec.Run(cmd, "--query_guid")
if err != nil {
glog.Error(log("drv_cfg --query_guid failed: %v", err))
klog.Error(log("drv_cfg --query_guid failed: %v", err))
return "", err
}
c.sdcGuid = strings.TrimSpace(string(output))
c.sdcGUID = strings.TrimSpace(string(output))
}
return c.sdcGuid, nil
return c.sdcGUID, nil
}
// getSioDiskPaths traverse local disk devices to retrieve device path
@ -339,10 +339,14 @@ func (c *sioClient) getGuid() (string, error) {
func (c *sioClient) getSioDiskPaths() ([]os.FileInfo, error) {
files, err := ioutil.ReadDir(sioDiskIDPath)
if err != nil {
glog.Error(log("failed to ReadDir %s: %v", sioDiskIDPath, err))
if os.IsNotExist(err) {
// sioDiskIDPath may not exist yet which is fine
return []os.FileInfo{}, nil
}
klog.Error(log("failed to ReadDir %s: %v", sioDiskIDPath, err))
return nil, err
}
}
result := []os.FileInfo{}
for _, file := range files {
if c.diskRegex.MatchString(file.Name()) {
@ -356,13 +360,13 @@ func (c *sioClient) getSioDiskPaths() ([]os.FileInfo, error) {
// GetVolumeRefs counts the number of references an SIO volume has a disk device.
// This is useful in preventing premature detach.
func (c *sioClient) GetVolumeRefs(volId sioVolumeID) (refs int, err error) {
func (c *sioClient) GetVolumeRefs(volID sioVolumeID) (refs int, err error) {
files, err := c.getSioDiskPaths()
if err != nil {
return 0, err
}
for _, file := range files {
if strings.Contains(file.Name(), string(volId)) {
if strings.Contains(file.Name(), string(volID)) {
refs++
}
}
@ -387,7 +391,7 @@ func (c *sioClient) Devs() (map[string]string, error) {
volumeID := parts[3]
devPath, err := filepath.EvalSymlinks(fmt.Sprintf("%s/%s", sioDiskIDPath, f.Name()))
if err != nil {
glog.Error(log("devicepath-to-volID mapping error: %v", err))
klog.Error(log("devicepath-to-volID mapping error: %v", err))
return nil, err
}
// map volumeID to devicePath
@ -413,18 +417,18 @@ func (c *sioClient) WaitForAttachedDevice(token string) (string, error) {
case <-ticker.C:
devMap, err := c.Devs()
if err != nil {
glog.Error(log("failed while waiting for volume to attach: %v", err))
klog.Error(log("failed while waiting for volume to attach: %v", err))
return "", err
}
go func() {
glog.V(4).Info(log("waiting for volume %s to be mapped/attached", token))
klog.V(4).Info(log("waiting for volume %s to be mapped/attached", token))
}()
if path, ok := devMap[token]; ok {
glog.V(4).Info(log("device %s mapped to vol %s", path, token))
klog.V(4).Info(log("device %s mapped to vol %s", path, token))
return path, nil
}
case <-timer.C:
glog.Error(log("timed out while waiting for volume to be mapped to a device"))
klog.Error(log("timed out while waiting for volume to be mapped to a device"))
return "", fmt.Errorf("volume attach timeout")
}
}
@ -447,18 +451,18 @@ func (c *sioClient) WaitForDetachedDevice(token string) error {
case <-ticker.C:
devMap, err := c.Devs()
if err != nil {
glog.Error(log("failed while waiting for volume to unmap/detach: %v", err))
klog.Error(log("failed while waiting for volume to unmap/detach: %v", err))
return err
}
go func() {
glog.V(4).Info(log("waiting for volume %s to be unmapped/detached", token))
klog.V(4).Info(log("waiting for volume %s to be unmapped/detached", token))
}()
// cant find vol id, then ok.
if _, ok := devMap[token]; !ok {
return nil
}
case <-timer.C:
glog.Error(log("timed out while waiting for volume %s to be unmapped/detached", token))
klog.Error(log("timed out while waiting for volume %s to be unmapped/detached", token))
return fmt.Errorf("volume detach timeout")
}
}
@ -473,7 +477,7 @@ func (c *sioClient) findSystem(sysname string) (sys *siotypes.System, err error)
}
systems, err := c.client.GetInstance("")
if err != nil {
glog.Error(log("failed to retrieve instances: %v", err))
klog.Error(log("failed to retrieve instances: %v", err))
return nil, err
}
for _, sys = range systems {
@ -481,7 +485,7 @@ func (c *sioClient) findSystem(sysname string) (sys *siotypes.System, err error)
return sys, nil
}
}
glog.Error(log("system %s not found", sysname))
klog.Error(log("system %s not found", sysname))
return nil, errors.New("system not found")
}
@ -490,13 +494,13 @@ func (c *sioClient) findProtectionDomain(pdname string) (*siotypes.ProtectionDom
if c.sysClient != nil {
protectionDomain, err := c.sysClient.FindProtectionDomain("", pdname, "")
if err != nil {
glog.Error(log("failed to retrieve protection domains: %v", err))
klog.Error(log("failed to retrieve protection domains: %v", err))
return nil, err
}
c.pdClient.ProtectionDomain = protectionDomain
return protectionDomain, nil
}
glog.Error(log("protection domain %s not set", pdname))
klog.Error(log("protection domain %s not set", pdname))
return nil, errors.New("protection domain not set")
}
@ -505,13 +509,13 @@ func (c *sioClient) findStoragePool(spname string) (*siotypes.StoragePool, error
if c.pdClient != nil {
sp, err := c.pdClient.FindStoragePool("", spname, "")
if err != nil {
glog.Error(log("failed to retrieve storage pool: %v", err))
klog.Error(log("failed to retrieve storage pool: %v", err))
return nil, err
}
c.spClient.StoragePool = sp
return sp, nil
}
glog.Error(log("storage pool %s not set", spname))
klog.Error(log("storage pool %s not set", spname))
return nil, errors.New("storage pool not set")
}

54
vendor/k8s.io/kubernetes/pkg/volume/scaleio/sio_mgr.go generated vendored
View File

@ -22,7 +22,7 @@ import (
"k8s.io/kubernetes/pkg/util/mount"
"github.com/golang/glog"
"k8s.io/klog"
siotypes "github.com/codedellemc/goscaleio/types/v1"
)
@ -57,22 +57,22 @@ func newSioMgr(configs map[string]string, exec mount.Exec) (*sioMgr, error) {
// getClient safely returns an sioInterface
func (m *sioMgr) getClient() (sioInterface, error) {
if m.client == nil {
glog.V(4).Info(log("creating scaleio client"))
klog.V(4).Info(log("creating scaleio client"))
configs := m.configData
username := configs[confKey.username]
password := configs[confKey.password]
gateway := configs[confKey.gateway]
b, err := strconv.ParseBool(configs[confKey.sslEnabled])
if err != nil {
glog.Error(log("failed to parse sslEnabled, must be either \"true\" or \"false\""))
klog.Error(log("failed to parse sslEnabled, must be either \"true\" or \"false\""))
return nil, err
}
certsEnabled := b
glog.V(4).Info(log("creating new client for gateway %s", gateway))
klog.V(4).Info(log("creating new client for gateway %s", gateway))
client, err := newSioClient(gateway, username, password, certsEnabled, m.exec)
if err != nil {
glog.Error(log("failed to create scaleio client: %v", err))
klog.Error(log("failed to create scaleio client: %v", err))
return nil, err
}
@ -81,11 +81,11 @@ func (m *sioMgr) getClient() (sioInterface, error) {
client.spName = configs[confKey.storagePool]
client.sdcPath = configs[confKey.sdcRootPath]
client.provisionMode = configs[confKey.storageMode]
client.sdcGuid = configs[confKey.sdcGuid]
client.sdcGUID = configs[confKey.sdcGUID]
m.client = client
glog.V(4).Info(log("client created successfully [gateway=%s]", gateway))
klog.V(4).Info(log("client created successfully [gateway=%s]", gateway))
}
return m.client, nil
}
@ -97,13 +97,13 @@ func (m *sioMgr) CreateVolume(volName string, sizeGB int64) (*siotypes.Volume, e
return nil, err
}
glog.V(4).Infof("scaleio: creating volume %s", volName)
klog.V(4).Infof("scaleio: creating volume %s", volName)
vol, err := client.CreateVolume(volName, sizeGB)
if err != nil {
glog.V(4).Infof("scaleio: failed creating volume %s: %v", volName, err)
klog.V(4).Infof("scaleio: failed creating volume %s: %v", volName, err)
return nil, err
}
glog.V(4).Infof("scaleio: created volume %s successfully", volName)
klog.V(4).Infof("scaleio: created volume %s successfully", volName)
return vol, nil
}
@ -112,17 +112,17 @@ func (m *sioMgr) CreateVolume(volName string, sizeGB int64) (*siotypes.Volume, e
func (m *sioMgr) AttachVolume(volName string, multipleMappings bool) (string, error) {
client, err := m.getClient()
if err != nil {
glog.Error(log("attach volume failed: %v", err))
klog.Error(log("attach volume failed: %v", err))
return "", err
}
glog.V(4).Infoln(log("attaching volume %s", volName))
klog.V(4).Infoln(log("attaching volume %s", volName))
iid, err := client.IID()
if err != nil {
glog.Error(log("failed to get instanceID"))
klog.Error(log("failed to get instanceID"))
return "", err
}
glog.V(4).Info(log("attaching volume %s to host instance %s", volName, iid))
klog.V(4).Info(log("attaching volume %s to host instance %s", volName, iid))
devs, err := client.Devs()
if err != nil {
@ -131,29 +131,29 @@ func (m *sioMgr) AttachVolume(volName string, multipleMappings bool) (string, er
vol, err := client.FindVolume(volName)
if err != nil {
glog.Error(log("failed to find volume %s: %v", volName, err))
klog.Error(log("failed to find volume %s: %v", volName, err))
return "", err
}
// handle vol if already attached
if len(vol.MappedSdcInfo) > 0 {
if m.isSdcMappedToVol(iid, vol) {
glog.V(4).Info(log("skippping attachment, volume %s already attached to sdc %s", volName, iid))
klog.V(4).Info(log("skippping attachment, volume %s already attached to sdc %s", volName, iid))
return devs[vol.ID], nil
}
}
// attach volume, get deviceName
if err := client.AttachVolume(sioVolumeID(vol.ID), multipleMappings); err != nil {
glog.Error(log("attachment for volume %s failed :%v", volName, err))
klog.Error(log("attachment for volume %s failed :%v", volName, err))
return "", err
}
device, err := client.WaitForAttachedDevice(vol.ID)
if err != nil {
glog.Error(log("failed while waiting for device to attach: %v", err))
klog.Error(log("failed while waiting for device to attach: %v", err))
return "", err
}
glog.V(4).Info(log("volume %s attached successfully as %s to instance %s", volName, device, iid))
klog.V(4).Info(log("volume %s attached successfully as %s to instance %s", volName, device, iid))
return device, nil
}
@ -165,7 +165,7 @@ func (m *sioMgr) IsAttached(volName string) (bool, error) {
}
iid, err := client.IID()
if err != nil {
glog.Error("scaleio: failed to get instanceID")
klog.Error("scaleio: failed to get instanceID")
return false, err
}
@ -184,7 +184,7 @@ func (m *sioMgr) DetachVolume(volName string) error {
}
iid, err := client.IID()
if err != nil {
glog.Error(log("failed to get instanceID: %v", err))
klog.Error(log("failed to get instanceID: %v", err))
return err
}
@ -193,7 +193,7 @@ func (m *sioMgr) DetachVolume(volName string) error {
return err
}
if !m.isSdcMappedToVol(iid, vol) {
glog.Warning(log(
klog.Warning(log(
"skipping detached, vol %s not attached to instance %s",
volName, iid,
))
@ -201,11 +201,11 @@ func (m *sioMgr) DetachVolume(volName string) error {
}
if err := client.DetachVolume(sioVolumeID(vol.ID)); err != nil {
glog.Error(log("failed to detach vol %s: %v", volName, err))
klog.Error(log("failed to detach vol %s: %v", volName, err))
return err
}
glog.V(4).Info(log("volume %s detached successfully", volName))
klog.V(4).Info(log("volume %s detached successfully", volName))
return nil
}
@ -223,11 +223,11 @@ func (m *sioMgr) DeleteVolume(volName string) error {
}
if err := client.DeleteVolume(sioVolumeID(vol.ID)); err != nil {
glog.Error(log("failed to delete volume %s: %v", volName, err))
klog.Error(log("failed to delete volume %s: %v", volName, err))
return err
}
glog.V(4).Info(log("deleted volume %s successfully", volName))
klog.V(4).Info(log("deleted volume %s successfully", volName))
return nil
}
@ -235,7 +235,7 @@ func (m *sioMgr) DeleteVolume(volName string) error {
// isSdcMappedToVol returns true if the sdc is mapped to the volume
func (m *sioMgr) isSdcMappedToVol(sdcID string, vol *siotypes.Volume) bool {
if len(vol.MappedSdcInfo) == 0 {
glog.V(4).Info(log("no attachment found"))
klog.V(4).Info(log("no attachment found"))
return false
}

2
vendor/k8s.io/kubernetes/pkg/volume/scaleio/sio_mgr_test.go generated vendored
View File

@ -311,7 +311,7 @@ func (f *fakeSio) Devs() (map[string]string, error) {
return f.devs, nil
}
func (f *fakeSio) GetVolumeRefs(volId sioVolumeID) (int, error) {
func (f *fakeSio) GetVolumeRefs(volID sioVolumeID) (int, error) {
if f.volume == nil {
return 0, nil
}

13
vendor/k8s.io/kubernetes/pkg/volume/scaleio/sio_plugin.go generated vendored
View File

@ -19,9 +19,9 @@ package scaleio
import (
"errors"
"github.com/golang/glog"
api "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/klog"
"k8s.io/kubernetes/pkg/util/keymutex"
"k8s.io/kubernetes/pkg/volume"
)
@ -36,6 +36,7 @@ type sioPlugin struct {
volumeMtx keymutex.KeyMutex
}
// ProbeVolumePlugins is the primary entrypoint for volume plugins.
func ProbeVolumePlugins() []volume.VolumePlugin {
p := &sioPlugin{
host: nil,
@ -50,7 +51,7 @@ var _ volume.VolumePlugin = &sioPlugin{}
func (p *sioPlugin) Init(host volume.VolumeHost) error {
p.host = host
p.volumeMtx = keymutex.NewKeyMutex()
p.volumeMtx = keymutex.NewHashed(0)
return nil
}
@ -107,7 +108,7 @@ func (p *sioPlugin) NewMounter(
// NewUnmounter creates a representation of the volume to unmount
func (p *sioPlugin) NewUnmounter(specName string, podUID types.UID) (volume.Unmounter, error) {
glog.V(4).Info(log("Unmounter for %s", specName))
klog.V(4).Info(log("Unmounter for %s", specName))
return &sioVolume{
podUID: podUID,
@ -160,7 +161,7 @@ var _ volume.DeletableVolumePlugin = &sioPlugin{}
func (p *sioPlugin) NewDeleter(spec *volume.Spec) (volume.Deleter, error) {
attribs, err := getVolumeSourceAttribs(spec)
if err != nil {
glog.Error(log("deleter failed to extract volume attributes from spec: %v", err))
klog.Error(log("deleter failed to extract volume attributes from spec: %v", err))
return nil, err
}
@ -186,11 +187,11 @@ func (p *sioPlugin) NewDeleter(spec *volume.Spec) (volume.Deleter, error) {
var _ volume.ProvisionableVolumePlugin = &sioPlugin{}
func (p *sioPlugin) NewProvisioner(options volume.VolumeOptions) (volume.Provisioner, error) {
glog.V(4).Info(log("creating Provisioner"))
klog.V(4).Info(log("creating Provisioner"))
configData := options.Parameters
if configData == nil {
glog.Error(log("provisioner missing parameters, unable to continue"))
klog.Error(log("provisioner missing parameters, unable to continue"))
return nil, errors.New("option parameters missing")
}

54
vendor/k8s.io/kubernetes/pkg/volume/scaleio/sio_util.go generated vendored
View File

@ -24,7 +24,7 @@ import (
"path"
"strconv"
"github.com/golang/glog"
"k8s.io/klog"
api "k8s.io/api/core/v1"
"k8s.io/kubernetes/pkg/volume"
@ -54,7 +54,7 @@ var (
username,
password,
secretNamespace,
sdcGuid string
sdcGUID string
}{
gateway: "gateway",
sslEnabled: "sslEnabled",
@ -71,9 +71,9 @@ var (
readOnly: "readOnly",
username: "username",
password: "password",
sdcGuid: "sdcGuid",
sdcGUID: "sdcGUID",
}
sdcGuidLabelName = "scaleio.sdcGuid"
sdcGUIDLabelName = "scaleio.sdcGUID"
sdcRootPath = "/opt/emc/scaleio/sdc/bin"
secretNotFoundErr = errors.New("secret not found")
@ -140,7 +140,7 @@ func validateConfigs(config map[string]string) error {
func applyConfigDefaults(config map[string]string) {
b, err := strconv.ParseBool(config[confKey.sslEnabled])
if err != nil {
glog.Warning(log("failed to parse param sslEnabled, setting it to false"))
klog.Warning(log("failed to parse param sslEnabled, setting it to false"))
b = false
}
config[confKey.sslEnabled] = strconv.FormatBool(b)
@ -148,7 +148,7 @@ func applyConfigDefaults(config map[string]string) {
config[confKey.fsType] = defaultString(config[confKey.fsType], "xfs")
b, err = strconv.ParseBool(config[confKey.readOnly])
if err != nil {
glog.Warning(log("failed to parse param readOnly, setting it to false"))
klog.Warning(log("failed to parse param readOnly, setting it to false"))
b = false
}
config[confKey.readOnly] = strconv.FormatBool(b)
@ -163,21 +163,21 @@ func defaultString(val, defVal string) string {
// loadConfig loads configuration data from a file on disk
func loadConfig(configName string) (map[string]string, error) {
glog.V(4).Info(log("loading config file %s", configName))
klog.V(4).Info(log("loading config file %s", configName))
file, err := os.Open(configName)
if err != nil {
glog.Error(log("failed to open config file %s: %v", configName, err))
klog.Error(log("failed to open config file %s: %v", configName, err))
return nil, err
}
defer file.Close()
data := map[string]string{}
if err := gob.NewDecoder(file).Decode(&data); err != nil {
glog.Error(log("failed to parse config data %s: %v", configName, err))
klog.Error(log("failed to parse config data %s: %v", configName, err))
return nil, err
}
applyConfigDefaults(data)
if err := validateConfigs(data); err != nil {
glog.Error(log("failed to load ConfigMap %s: %v", err))
klog.Error(log("failed to load ConfigMap %s: %v", err))
return nil, err
}
@ -186,31 +186,31 @@ func loadConfig(configName string) (map[string]string, error) {
// saveConfig saves the configuration data to local disk
func saveConfig(configName string, data map[string]string) error {
glog.V(4).Info(log("saving config file %s", configName))
klog.V(4).Info(log("saving config file %s", configName))
dir := path.Dir(configName)
if _, err := os.Stat(dir); err != nil {
if !os.IsNotExist(err) {
return err
}
glog.V(4).Info(log("creating config dir for config data: %s", dir))
klog.V(4).Info(log("creating config dir for config data: %s", dir))
if err := os.MkdirAll(dir, 0750); err != nil {
glog.Error(log("failed to create config data dir %v", err))
klog.Error(log("failed to create config data dir %v", err))
return err
}
}
file, err := os.Create(configName)
if err != nil {
glog.V(4).Info(log("failed to save config data file %s: %v", configName, err))
klog.V(4).Info(log("failed to save config data file %s: %v", configName, err))
return err
}
defer file.Close()
if err := gob.NewEncoder(file).Encode(data); err != nil {
glog.Error(log("failed to save config %s: %v", configName, err))
klog.Error(log("failed to save config %s: %v", configName, err))
return err
}
glog.V(4).Info(log("config data file saved successfully as %s", configName))
klog.V(4).Info(log("config data file saved successfully as %s", configName))
return nil
}
@ -221,7 +221,7 @@ func attachSecret(plug *sioPlugin, namespace string, configData map[string]strin
kubeClient := plug.host.GetKubeClient()
secretMap, err := volutil.GetSecretForPV(namespace, secretRefName, sioPluginName, kubeClient)
if err != nil {
glog.Error(log("failed to get secret: %v", err))
klog.Error(log("failed to get secret: %v", err))
return secretNotFoundErr
}
// merge secret data
@ -232,30 +232,30 @@ func attachSecret(plug *sioPlugin, namespace string, configData map[string]strin
return nil
}
// attachSdcGuid injects the sdc guid node label value into config
func attachSdcGuid(plug *sioPlugin, conf map[string]string) error {
guid, err := getSdcGuidLabel(plug)
// attachSdcGUID injects the sdc guid node label value into config
func attachSdcGUID(plug *sioPlugin, conf map[string]string) error {
guid, err := getSdcGUIDLabel(plug)
if err != nil {
return err
}
conf[confKey.sdcGuid] = guid
conf[confKey.sdcGUID] = guid
return nil
}
// getSdcGuidLabel fetches the scaleio.sdcGuid node label
// getSdcGUIDLabel fetches the scaleio.sdcGuid node label
// associated with the node executing this code.
func getSdcGuidLabel(plug *sioPlugin) (string, error) {
func getSdcGUIDLabel(plug *sioPlugin) (string, error) {
nodeLabels, err := plug.host.GetNodeLabels()
if err != nil {
return "", err
}
label, ok := nodeLabels[sdcGuidLabelName]
label, ok := nodeLabels[sdcGUIDLabelName]
if !ok {
glog.V(4).Info(log("node label %s not found", sdcGuidLabelName))
klog.V(4).Info(log("node label %s not found", sdcGUIDLabelName))
return "", nil
}
glog.V(4).Info(log("found node label %s=%s", sdcGuidLabelName, label))
klog.V(4).Info(log("found node label %s=%s", sdcGUIDLabelName, label))
return label, nil
}
@ -284,7 +284,7 @@ func getVolumeSourceAttribs(spec *volume.Spec) (*volSourceAttribs, error) {
attribs.readOnly = pSource.ReadOnly
} else {
msg := log("failed to get ScaleIOVolumeSource or ScaleIOPersistentVolumeSource from spec")
glog.Error(msg)
klog.Error(msg)
return nil, errors.New(msg)
}
return attribs, nil

114
vendor/k8s.io/kubernetes/pkg/volume/scaleio/sio_volume.go generated vendored
View File

@ -23,12 +23,12 @@ import (
"strconv"
"strings"
"github.com/golang/glog"
api "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/api/resource"
meta "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/types"
"k8s.io/apimachinery/pkg/util/uuid"
"k8s.io/klog"
"k8s.io/kubernetes/pkg/util/mount"
kstrings "k8s.io/kubernetes/pkg/util/strings"
"k8s.io/kubernetes/pkg/volume"
@ -85,20 +85,20 @@ func (v *sioVolume) SetUpAt(dir string, fsGroup *int64) error {
v.plugin.volumeMtx.LockKey(v.volSpecName)
defer v.plugin.volumeMtx.UnlockKey(v.volSpecName)
glog.V(4).Info(log("setting up volume for PV.spec %s", v.volSpecName))
klog.V(4).Info(log("setting up volume for PV.spec %s", v.volSpecName))
if err := v.setSioMgr(); err != nil {
glog.Error(log("setup failed to create scalio manager: %v", err))
klog.Error(log("setup failed to create scalio manager: %v", err))
return err
}
mounter := v.plugin.host.GetMounter(v.plugin.GetPluginName())
notDevMnt, err := mounter.IsLikelyNotMountPoint(dir)
if err != nil && !os.IsNotExist(err) {
glog.Error(log("IsLikelyNotMountPoint test failed for dir %v", dir))
klog.Error(log("IsLikelyNotMountPoint test failed for dir %v", dir))
return err
}
if !notDevMnt {
glog.V(4).Info(log("skipping setup, dir %s already a mount point", v.volName))
klog.V(4).Info(log("skipping setup, dir %s already a mount point", v.volName))
return nil
}
@ -114,12 +114,12 @@ func (v *sioVolume) SetUpAt(dir string, fsGroup *int64) error {
}
}
}
glog.V(4).Info(log("multiple mapping enabled = %v", enableMultiMaps))
klog.V(4).Info(log("multiple mapping enabled = %v", enableMultiMaps))
volName := v.volName
devicePath, err := v.sioMgr.AttachVolume(volName, enableMultiMaps)
if err != nil {
glog.Error(log("setup of volume %v: %v", v.volSpecName, err))
klog.Error(log("setup of volume %v: %v", v.volSpecName, err))
return err
}
options := []string{}
@ -134,31 +134,31 @@ func (v *sioVolume) SetUpAt(dir string, fsGroup *int64) error {
options = append(options, "ro")
}
glog.V(4).Info(log("mounting device %s -> %s", devicePath, dir))
klog.V(4).Info(log("mounting device %s -> %s", devicePath, dir))
if err := os.MkdirAll(dir, 0750); err != nil {
glog.Error(log("failed to create dir %#v: %v", dir, err))
klog.Error(log("failed to create dir %#v: %v", dir, err))
return err
}
glog.V(4).Info(log("setup created mount point directory %s", dir))
klog.V(4).Info(log("setup created mount point directory %s", dir))
diskMounter := util.NewSafeFormatAndMountFromHost(v.plugin.GetPluginName(), v.plugin.host)
err = diskMounter.FormatAndMount(devicePath, dir, v.fsType, options)
if err != nil {
glog.Error(log("mount operation failed during setup: %v", err))
klog.Error(log("mount operation failed during setup: %v", err))
if err := os.Remove(dir); err != nil && !os.IsNotExist(err) {
glog.Error(log("failed to remove dir %s during a failed mount at setup: %v", dir, err))
klog.Error(log("failed to remove dir %s during a failed mount at setup: %v", dir, err))
return err
}
return err
}
if !v.readOnly && fsGroup != nil {
glog.V(4).Info(log("applying value FSGroup ownership"))
klog.V(4).Info(log("applying value FSGroup ownership"))
volume.SetVolumeOwnership(v, fsGroup)
}
glog.V(4).Info(log("successfully setup PV %s: volume %s mapped as %s mounted at %s", v.volSpecName, v.volName, devicePath, dir))
klog.V(4).Info(log("successfully setup PV %s: volume %s mapped as %s mounted at %s", v.volSpecName, v.volName, devicePath, dir))
return nil
}
@ -188,21 +188,21 @@ func (v *sioVolume) TearDownAt(dir string) error {
mounter := v.plugin.host.GetMounter(v.plugin.GetPluginName())
dev, _, err := mount.GetDeviceNameFromMount(mounter, dir)
if err != nil {
glog.Errorf(log("failed to get reference count for volume: %s", dir))
klog.Errorf(log("failed to get reference count for volume: %s", dir))
return err
}
glog.V(4).Info(log("attempting to unmount %s", dir))
klog.V(4).Info(log("attempting to unmount %s", dir))
if err := util.UnmountPath(dir, mounter); err != nil {
glog.Error(log("teardown failed while unmounting dir %s: %v ", dir, err))
klog.Error(log("teardown failed while unmounting dir %s: %v ", dir, err))
return err
}
glog.V(4).Info(log("dir %s unmounted successfully", dir))
klog.V(4).Info(log("dir %s unmounted successfully", dir))
// detach/unmap
deviceBusy, err := mounter.DeviceOpened(dev)
if err != nil {
glog.Error(log("teardown unable to get status for device %s: %v", dev, err))
klog.Error(log("teardown unable to get status for device %s: %v", dev, err))
return err
}
@ -210,16 +210,16 @@ func (v *sioVolume) TearDownAt(dir string) error {
// use "last attempt wins" strategy to detach volume from node
// only allow volume to detach when it is not busy (not being used by other pods)
if !deviceBusy {
glog.V(4).Info(log("teardown is attempting to detach/unmap volume for PV %s", v.volSpecName))
klog.V(4).Info(log("teardown is attempting to detach/unmap volume for PV %s", v.volSpecName))
if err := v.resetSioMgr(); err != nil {
glog.Error(log("teardown failed, unable to reset scalio mgr: %v", err))
klog.Error(log("teardown failed, unable to reset scalio mgr: %v", err))
}
volName := v.volName
if err := v.sioMgr.DetachVolume(volName); err != nil {
glog.Warning(log("warning: detaching failed for volume %s: %v", volName, err))
klog.Warning(log("warning: detaching failed for volume %s: %v", volName, err))
return nil
}
glog.V(4).Infof(log("teardown of volume %v detached successfully", volName))
klog.V(4).Infof(log("teardown of volume %v detached successfully", volName))
}
return nil
}
@ -230,20 +230,20 @@ func (v *sioVolume) TearDownAt(dir string) error {
var _ volume.Deleter = &sioVolume{}
func (v *sioVolume) Delete() error {
glog.V(4).Info(log("deleting pvc %s", v.volSpecName))
klog.V(4).Info(log("deleting pvc %s", v.volSpecName))
if err := v.setSioMgrFromSpec(); err != nil {
glog.Error(log("delete failed while setting sio manager: %v", err))
klog.Error(log("delete failed while setting sio manager: %v", err))
return err
}
err := v.sioMgr.DeleteVolume(v.volName)
if err != nil {
glog.Error(log("failed to delete volume %s: %v", v.volName, err))
klog.Error(log("failed to delete volume %s: %v", v.volName, err))
return err
}
glog.V(4).Info(log("successfully deleted PV %s with volume %s", v.volSpecName, v.volName))
klog.V(4).Info(log("successfully deleted PV %s with volume %s", v.volSpecName, v.volName))
return nil
}
@ -253,7 +253,7 @@ func (v *sioVolume) Delete() error {
var _ volume.Provisioner = &sioVolume{}
func (v *sioVolume) Provision(selectedNode *api.Node, allowedTopologies []api.TopologySelectorTerm) (*api.PersistentVolume, error) {
glog.V(4).Info(log("attempting to dynamically provision pvc %v", v.options.PVC.Name))
klog.V(4).Info(log("attempting to dynamically provision pvc %v", v.options.PVC.Name))
if !util.AccessModesContainedInAll(v.plugin.GetAccessModes(), v.options.PVC.Spec.AccessModes) {
return nil, fmt.Errorf("invalid AccessModes %v: only AccessModes %v are supported", v.options.PVC.Spec.AccessModes, v.plugin.GetAccessModes())
@ -266,7 +266,7 @@ func (v *sioVolume) Provision(selectedNode *api.Node, allowedTopologies []api.To
// setup volume attrributes
genName := v.generateName("k8svol", 11)
var oneGig int64 = 1024 * 1024 * 1024
var eightGig int64 = 8 * oneGig
eightGig := 8 * oneGig
capacity := v.options.PVC.Spec.Resources.Requests[api.ResourceName(api.ResourceStorage)]
volSizeBytes := capacity.Value()
@ -278,13 +278,13 @@ func (v *sioVolume) Provision(selectedNode *api.Node, allowedTopologies []api.To
if volSizeBytes < eightGig {
volSizeGB = int64(util.RoundUpSize(eightGig, oneGig))
glog.V(4).Info(log("capacity less than 8Gi found, adjusted to %dGi", volSizeGB))
klog.V(4).Info(log("capacity less than 8Gi found, adjusted to %dGi", volSizeGB))
}
// create sio manager
if err := v.setSioMgrFromConfig(); err != nil {
glog.Error(log("provision failed while setting up sio mgr: %v", err))
klog.Error(log("provision failed while setting up sio mgr: %v", err))
return nil, err
}
@ -292,7 +292,7 @@ func (v *sioVolume) Provision(selectedNode *api.Node, allowedTopologies []api.To
volName := genName
vol, err := v.sioMgr.CreateVolume(volName, volSizeGB)
if err != nil {
glog.Error(log("provision failed while creating volume: %v", err))
klog.Error(log("provision failed while creating volume: %v", err))
return nil, err
}
@ -300,12 +300,12 @@ func (v *sioVolume) Provision(selectedNode *api.Node, allowedTopologies []api.To
v.configData[confKey.volumeName] = volName
sslEnabled, err := strconv.ParseBool(v.configData[confKey.sslEnabled])
if err != nil {
glog.Warning(log("failed to parse parameter sslEnabled, setting to false"))
klog.Warning(log("failed to parse parameter sslEnabled, setting to false"))
sslEnabled = false
}
readOnly, err := strconv.ParseBool(v.configData[confKey.readOnly])
if err != nil {
glog.Warning(log("failed to parse parameter readOnly, setting it to false"))
klog.Warning(log("failed to parse parameter readOnly, setting it to false"))
readOnly = false
}
@ -348,24 +348,24 @@ func (v *sioVolume) Provision(selectedNode *api.Node, allowedTopologies []api.To
pv.Spec.AccessModes = v.plugin.GetAccessModes()
}
glog.V(4).Info(log("provisioner created pv %v and volume %s successfully", pvName, vol.Name))
klog.V(4).Info(log("provisioner created pv %v and volume %s successfully", pvName, vol.Name))
return pv, nil
}
// setSioMgr creates scaleio mgr from cached config data if found
// otherwise, setups new config data and create mgr
func (v *sioVolume) setSioMgr() error {
glog.V(4).Info(log("setting up sio mgr for spec %s", v.volSpecName))
klog.V(4).Info(log("setting up sio mgr for spec %s", v.volSpecName))
podDir := v.plugin.host.GetPodPluginDir(v.podUID, sioPluginName)
configName := path.Join(podDir, sioConfigFileName)
if v.sioMgr == nil {
configData, err := loadConfig(configName) // try to load config if exist
if err != nil {
if !os.IsNotExist(err) {
glog.Error(log("failed to load config %s : %v", configName, err))
klog.Error(log("failed to load config %s : %v", configName, err))
return err
}
glog.V(4).Info(log("previous config file not found, creating new one"))
klog.V(4).Info(log("previous config file not found, creating new one"))
// prepare config data
configData = make(map[string]string)
mapVolumeSpec(configData, v.spec)
@ -376,31 +376,31 @@ func (v *sioVolume) setSioMgr() error {
configData[confKey.volSpecName] = v.volSpecName
if err := validateConfigs(configData); err != nil {
glog.Error(log("config setup failed: %s", err))
klog.Error(log("config setup failed: %s", err))
return err
}
// persist config
if err := saveConfig(configName, configData); err != nil {
glog.Error(log("failed to save config data: %v", err))
klog.Error(log("failed to save config data: %v", err))
return err
}
}
// merge in secret
if err := attachSecret(v.plugin, v.secretNamespace, configData); err != nil {
glog.Error(log("failed to load secret: %v", err))
klog.Error(log("failed to load secret: %v", err))
return err
}
// merge in Sdc Guid label value
if err := attachSdcGuid(v.plugin, configData); err != nil {
glog.Error(log("failed to retrieve sdc guid: %v", err))
if err := attachSdcGUID(v.plugin, configData); err != nil {
klog.Error(log("failed to retrieve sdc guid: %v", err))
return err
}
mgr, err := newSioMgr(configData, v.plugin.host.GetExec(v.plugin.GetPluginName()))
if err != nil {
glog.Error(log("failed to reset sio manager: %v", err))
klog.Error(log("failed to reset sio manager: %v", err))
return err
}
@ -417,7 +417,7 @@ func (v *sioVolume) resetSioMgr() error {
// load config data from disk
configData, err := loadConfig(configName)
if err != nil {
glog.Error(log("failed to load config data: %v", err))
klog.Error(log("failed to load config data: %v", err))
return err
}
v.secretName = configData[confKey.secretName]
@ -427,20 +427,20 @@ func (v *sioVolume) resetSioMgr() error {
// attach secret
if err := attachSecret(v.plugin, v.secretNamespace, configData); err != nil {
glog.Error(log("failed to load secret: %v", err))
klog.Error(log("failed to load secret: %v", err))
return err
}
// merge in Sdc Guid label value
if err := attachSdcGuid(v.plugin, configData); err != nil {
glog.Error(log("failed to retrieve sdc guid: %v", err))
if err := attachSdcGUID(v.plugin, configData); err != nil {
klog.Error(log("failed to retrieve sdc guid: %v", err))
return err
}
mgr, err := newSioMgr(configData, v.plugin.host.GetExec(v.plugin.GetPluginName()))
if err != nil {
glog.Error(log("failed to reset scaleio mgr: %v", err))
klog.Error(log("failed to reset scaleio mgr: %v", err))
return err
}
v.sioMgr = mgr
@ -451,14 +451,14 @@ func (v *sioVolume) resetSioMgr() error {
// setSioFromConfig sets up scaleio mgr from an available config data map
// designed to be called from dynamic provisioner
func (v *sioVolume) setSioMgrFromConfig() error {
glog.V(4).Info(log("setting scaleio mgr from available config"))
klog.V(4).Info(log("setting scaleio mgr from available config"))
if v.sioMgr == nil {
applyConfigDefaults(v.configData)
v.configData[confKey.volSpecName] = v.volSpecName
if err := validateConfigs(v.configData); err != nil {
glog.Error(log("config data setup failed: %s", err))
klog.Error(log("config data setup failed: %s", err))
return err
}
@ -469,14 +469,14 @@ func (v *sioVolume) setSioMgrFromConfig() error {
}
if err := attachSecret(v.plugin, v.secretNamespace, data); err != nil {
glog.Error(log("failed to load secret: %v", err))
klog.Error(log("failed to load secret: %v", err))
return err
}
mgr, err := newSioMgr(data, v.plugin.host.GetExec(v.plugin.GetPluginName()))
if err != nil {
glog.Error(log("failed while setting scaleio mgr from config: %v", err))
klog.Error(log("failed while setting scaleio mgr from config: %v", err))
return err
}
v.sioMgr = mgr
@ -487,7 +487,7 @@ func (v *sioVolume) setSioMgrFromConfig() error {
// setSioMgrFromSpec sets the scaleio manager from a spec object.
// The spec may be complete or incomplete depending on lifecycle phase.
func (v *sioVolume) setSioMgrFromSpec() error {
glog.V(4).Info(log("setting sio manager from spec"))
klog.V(4).Info(log("setting sio manager from spec"))
if v.sioMgr == nil {
// get config data form spec volume source
configData := map[string]string{}
@ -499,20 +499,20 @@ func (v *sioVolume) setSioMgrFromSpec() error {
configData[confKey.volSpecName] = v.volSpecName
if err := validateConfigs(configData); err != nil {
glog.Error(log("config setup failed: %s", err))
klog.Error(log("config setup failed: %s", err))
return err
}
// attach secret object to config data
if err := attachSecret(v.plugin, v.secretNamespace, configData); err != nil {
glog.Error(log("failed to load secret: %v", err))
klog.Error(log("failed to load secret: %v", err))
return err
}
mgr, err := newSioMgr(configData, v.plugin.host.GetExec(v.plugin.GetPluginName()))
if err != nil {
glog.Error(log("failed to reset sio manager: %v", err))
klog.Error(log("failed to reset sio manager: %v", err))
return err
}
v.sioMgr = mgr

40
vendor/k8s.io/kubernetes/pkg/volume/scaleio/sio_volume_test.go generated vendored
View File

@ -23,7 +23,7 @@ import (
"strings"
"testing"
"github.com/golang/glog"
"k8s.io/klog"
api "k8s.io/api/core/v1"
meta "k8s.io/apimachinery/pkg/apis/meta/v1"
@ -56,7 +56,7 @@ func newPluginMgr(t *testing.T, apiObject runtime.Object) (*volume.VolumePluginM
tmpDir,
fakeClient,
nil,
map[string]string{sdcGuidLabelName: "abc-123"},
map[string]string{sdcGUIDLabelName: "abc-123"},
)
plugMgr := &volume.VolumePluginMgr{}
plugMgr.InitPlugins(ProbeVolumePlugins(), nil /* prober */, host)
@ -206,9 +206,9 @@ func TestVolumeMounterUnmounter(t *testing.T) {
t.Errorf("SetUp() - expecting multiple volume disabled by default")
}
// did we read sdcGuid label
if _, ok := sioVol.sioMgr.configData[confKey.sdcGuid]; !ok {
t.Errorf("Expected to find node label scaleio.sdcGuid, but did not find it")
// did we read sdcGUID label
if _, ok := sioVol.sioMgr.configData[confKey.sdcGUID]; !ok {
t.Errorf("Expected to find node label scaleio.sdcGUID, but did not find it")
}
// rebuild spec
@ -263,8 +263,8 @@ func TestVolumeProvisioner(t *testing.T) {
}
options := volume.VolumeOptions{
ClusterName: "testcluster",
PVC: volumetest.CreateTestPVC("100Mi", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}),
ClusterName: "testcluster",
PVC: volumetest.CreateTestPVC("100Mi", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}),
PersistentVolumeReclaimPolicy: api.PersistentVolumeReclaimDelete,
}
options.PVC.Name = "testpvc"
@ -328,7 +328,7 @@ func TestVolumeProvisioner(t *testing.T) {
t.Errorf("expected volume name to be %s, got %s", actualVolName, vol.Name)
}
if vol.SizeInKb != 8*1024*1024 {
glog.V(4).Info(log("unexpected volume size"))
klog.V(4).Info(log("unexpected volume size"))
}
// mount dynamic vol
@ -349,9 +349,9 @@ func TestVolumeProvisioner(t *testing.T) {
t.Fatalf("Expected success, got: %v", err)
}
// did we read sdcGuid label
if _, ok := sioVol.sioMgr.configData[confKey.sdcGuid]; !ok {
t.Errorf("Expected to find node label scaleio.sdcGuid, but did not find it")
// did we read sdcGUID label
if _, ok := sioVol.sioMgr.configData[confKey.sdcGUID]; !ok {
t.Errorf("Expected to find node label scaleio.sdcGUID, but did not find it")
}
// isMultiMap applied
@ -408,9 +408,9 @@ func TestVolumeProvisionerWithIncompleteConfig(t *testing.T) {
}
options := volume.VolumeOptions{
ClusterName: "testcluster",
PVName: "pvc-sio-dynamic-vol",
PVC: volumetest.CreateTestPVC("100Mi", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}),
ClusterName: "testcluster",
PVName: "pvc-sio-dynamic-vol",
PVC: volumetest.CreateTestPVC("100Mi", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}),
PersistentVolumeReclaimPolicy: api.PersistentVolumeReclaimDelete,
}
options.PVC.Namespace = testns
@ -440,9 +440,9 @@ func TestVolumeProvisionerWithZeroCapacity(t *testing.T) {
}
options := volume.VolumeOptions{
ClusterName: "testcluster",
PVName: "pvc-sio-dynamic-vol",
PVC: volumetest.CreateTestPVC("0Mi", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}),
ClusterName: "testcluster",
PVName: "pvc-sio-dynamic-vol",
PVC: volumetest.CreateTestPVC("0Mi", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}),
PersistentVolumeReclaimPolicy: api.PersistentVolumeReclaimDelete,
}
options.PVC.Namespace = testns
@ -488,9 +488,9 @@ func TestVolumeProvisionerWithSecretNamespace(t *testing.T) {
}
options := volume.VolumeOptions{
ClusterName: "testcluster",
PVName: "pvc-sio-dynamic-vol",
PVC: volumetest.CreateTestPVC("100Mi", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}),
ClusterName: "testcluster",
PVName: "pvc-sio-dynamic-vol",
PVC: volumetest.CreateTestPVC("100Mi", []api.PersistentVolumeAccessMode{api.ReadWriteOnce}),
PersistentVolumeReclaimPolicy: api.PersistentVolumeReclaimDelete,
}