github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-03 17:30:00 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #51213 from humblec/glusterfs-error

Browse Source 
Automatic merge from submit-queue (batch tested with PRs 51229, 50131, 51074, 51167, 51213)

Avoid explicit mention of plugin name in error strings.
This commit is contained in:
Kubernetes Submit Queue 2017-08-25 03:16:11 -07:00 committed by GitHub
commit 59a63be022
1 changed files with 71 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
pkg/volume/glusterfs/glusterfs.go
View File

@ -142,14 +142,14 @@ func (plugin *glusterfsPlugin) NewMounter(spec *volume.Spec, pod *v1.Pod, _ volu
podNs := pod.Namespace podNs := pod.Namespace
kubeClient := plugin.host.GetKubeClient() kubeClient := plugin.host.GetKubeClient()
if kubeClient == nil { if kubeClient == nil {
return nil, fmt.Errorf("glusterfs: failed to get kube client to initialize mounter") return nil, fmt.Errorf("failed to get kube client to initialize mounter")
} }
ep, err := kubeClient.Core().Endpoints(podNs).Get(epName, metav1.GetOptions{}) ep, err := kubeClient.Core().Endpoints(podNs).Get(epName, metav1.GetOptions{})
if err != nil { if err != nil {
glog.Errorf("glusterfs: failed to get endpoints %s[%v]", epName, err) glog.Errorf("failed to get endpoints %s[%v]", epName, err)
return nil, err return nil, err
} }
glog.V(1).Infof("glusterfs: endpoints %v", ep) glog.V(1).Infof("glusterfs pv endpoint %v", ep)
return plugin.newMounterInternal(spec, ep, pod, plugin.host.GetMounter(plugin.GetPluginName())) return plugin.newMounterInternal(spec, ep, pod, plugin.host.GetMounter(plugin.GetPluginName()))
} }
@ -252,7 +252,7 @@ func (b *glusterfsMounter) SetUp(fsGroup *int64) error {
func (b *glusterfsMounter) SetUpAt(dir string, fsGroup *int64) error { func (b *glusterfsMounter) SetUpAt(dir string, fsGroup *int64) error {
notMnt, err := b.mounter.IsLikelyNotMountPoint(dir) notMnt, err := b.mounter.IsLikelyNotMountPoint(dir)
glog.V(4).Infof("glusterfs: mount setup: %s %v %v", dir, !notMnt, err) glog.V(4).Infof("mount setup: %s %v %v", dir, !notMnt, err)
if err != nil && !os.IsNotExist(err) { if err != nil && !os.IsNotExist(err) {
return err return err
} }
@ -300,7 +300,7 @@ func (b *glusterfsMounter) setUpAtInternal(dir string) error {
p := path.Join(b.glusterfs.plugin.host.GetPluginDir(glusterfsPluginName), b.glusterfs.volName) p := path.Join(b.glusterfs.plugin.host.GetPluginDir(glusterfsPluginName), b.glusterfs.volName)
if err := os.MkdirAll(p, 0750); err != nil { if err := os.MkdirAll(p, 0750); err != nil {
return fmt.Errorf("glusterfs: Error creating directory %v: %v", p, err) return fmt.Errorf("Error creating directory %v: %v", p, err)
} }
// adding log-level ERROR to remove noise // adding log-level ERROR to remove noise
@ -355,12 +355,12 @@ func (b *glusterfsMounter) setUpAtInternal(dir string) error {
} }
errs = b.mounter.Mount(ip+":"+b.path, dir, "glusterfs", noAutoMountOptions) errs = b.mounter.Mount(ip+":"+b.path, dir, "glusterfs", noAutoMountOptions)
if errs == nil { if errs == nil {
glog.Infof("glusterfs: successfully mounted %s", dir) glog.Infof("successfully mounted %s", dir)
return nil return nil
} }
} }
} else { } else {
return fmt.Errorf("glusterfs: failed to execute mount command:[no valid ipaddress found in endpoint address list]") return fmt.Errorf("failed to execute mount command:[no valid ipaddress found in endpoint address list]")
} }
// Failed mount scenario. // Failed mount scenario.
@ -368,9 +368,9 @@ func (b *glusterfsMounter) setUpAtInternal(dir string) error {
// it all goes in a log file, we will read the log file // it all goes in a log file, we will read the log file
logErr := readGlusterLog(log, b.pod.Name) logErr := readGlusterLog(log, b.pod.Name)
if logErr != nil { if logErr != nil {
return fmt.Errorf("glusterfs: mount failed: %v the following error information was pulled from the glusterfs log to help diagnose this issue: %v", errs, logErr) return fmt.Errorf("mount failed: %v the following error information was pulled from the glusterfs log to help diagnose this issue: %v", errs, logErr)
} }
return fmt.Errorf("glusterfs: mount failed: %v", errs) return fmt.Errorf("mount failed: %v", errs)
} }
@ -424,11 +424,11 @@ type glusterfsVolumeProvisioner struct {
func convertGid(gidString string) (int, error) { func convertGid(gidString string) (int, error) {
gid64, err := strconv.ParseInt(gidString, 10, 32) gid64, err := strconv.ParseInt(gidString, 10, 32)
if err != nil { if err != nil {
return 0, fmt.Errorf("glusterfs: failed to parse gid %v ", gidString) return 0, fmt.Errorf("failed to parse gid %v ", gidString)
} }
if gid64 < 0 { if gid64 < 0 {
return 0, fmt.Errorf("glusterfs: negative GIDs are not allowed: %v", gidString) return 0, fmt.Errorf("negative GIDs are not allowed: %v", gidString)
} }
// ParseInt returns a int64, but since we parsed only // ParseInt returns a int64, but since we parsed only
@ -486,11 +486,11 @@ func (d *glusterfsVolumeDeleter) GetPath() string {
func (plugin *glusterfsPlugin) collectGids(className string, gidTable *MinMaxAllocator) error { func (plugin *glusterfsPlugin) collectGids(className string, gidTable *MinMaxAllocator) error {
kubeClient := plugin.host.GetKubeClient() kubeClient := plugin.host.GetKubeClient()
if kubeClient == nil { if kubeClient == nil {
return fmt.Errorf("glusterfs: failed to get kube client when collecting gids") return fmt.Errorf("failed to get kube client when collecting gids")
} }
pvList, err := kubeClient.Core().PersistentVolumes().List(metav1.ListOptions{LabelSelector: labels.Everything().String()}) pvList, err := kubeClient.Core().PersistentVolumes().List(metav1.ListOptions{LabelSelector: labels.Everything().String()})
if err != nil { if err != nil {
glog.Errorf("glusterfs: failed to get existing persistent volumes") glog.Errorf("failed to get existing persistent volumes")
return err return err
} }
@ -504,7 +504,7 @@ func (plugin *glusterfsPlugin) collectGids(className string, gidTable *MinMaxAll
gidStr, ok := pv.Annotations[volumehelper.VolumeGidAnnotationKey] gidStr, ok := pv.Annotations[volumehelper.VolumeGidAnnotationKey]
if !ok { if !ok {
glog.Warningf("glusterfs: no gid found in pv '%v'", pvName) glog.Warningf("no GID found in pv '%v'", pvName)
continue continue
} }
@ -516,9 +516,9 @@ func (plugin *glusterfsPlugin) collectGids(className string, gidTable *MinMaxAll
_, err = gidTable.Allocate(gid) _, err = gidTable.Allocate(gid)
if err == ErrConflict { if err == ErrConflict {
glog.Warningf("glusterfs: gid %v found in pv %v was already allocated", gid) glog.Warningf("GID %v found in pv %v was already allocated", gid)
} else if err != nil { } else if err != nil {
glog.Errorf("glusterfs: failed to store gid %v found in pv '%v': %v", gid, pvName, err) glog.Errorf("failed to store gid %v found in pv '%v': %v", gid, pvName, err)
return err return err
} }
} }
@ -595,7 +595,7 @@ func (d *glusterfsVolumeDeleter) getGid() (int, bool, error) {
} }
func (d *glusterfsVolumeDeleter) Delete() error { func (d *glusterfsVolumeDeleter) Delete() error {
glog.V(2).Infof("glusterfs: delete volume: %s ", d.glusterfsMounter.path) glog.V(2).Infof("delete volume: %s ", d.glusterfsMounter.path)
volumeName := d.glusterfsMounter.path volumeName := d.glusterfsMounter.path
volumeID := dstrings.TrimPrefix(volumeName, volPrefix) volumeID := dstrings.TrimPrefix(volumeName, volPrefix)
class, err := volutil.GetClassForVolume(d.plugin.host.GetKubeClient(), d.spec) class, err := volutil.GetClassForVolume(d.plugin.host.GetKubeClient(), d.spec)
@ -609,7 +609,7 @@ func (d *glusterfsVolumeDeleter) Delete() error {
} }
d.provisionerConfig = *cfg d.provisionerConfig = *cfg
glog.V(4).Infof("glusterfs: deleting volume %q with configuration %+v", volumeID, d.provisionerConfig) glog.V(4).Infof("deleting volume %q with configuration %+v", volumeID, d.provisionerConfig)
gid, exists, err := d.getGid() gid, exists, err := d.getGid()
if err != nil { if err != nil {
@ -617,48 +617,48 @@ func (d *glusterfsVolumeDeleter) Delete() error {
} else if exists { } else if exists {
gidTable, err := d.plugin.getGidTable(class.Name, cfg.gidMin, cfg.gidMax) gidTable, err := d.plugin.getGidTable(class.Name, cfg.gidMin, cfg.gidMax)
if err != nil { if err != nil {
return fmt.Errorf("glusterfs: failed to get gidTable: %v", err) return fmt.Errorf("failed to get gidTable: %v", err)
} }
err = gidTable.Release(gid) err = gidTable.Release(gid)
if err != nil { if err != nil {
return fmt.Errorf("glusterfs: failed to release gid %v: %v", gid, err) return fmt.Errorf("failed to release gid %v: %v", gid, err)
} }
} }
cli := gcli.NewClient(d.url, d.user, d.secretValue) cli := gcli.NewClient(d.url, d.user, d.secretValue)
if cli == nil { if cli == nil {
glog.Errorf("glusterfs: failed to create glusterfs rest client") glog.Errorf("failed to create glusterfs rest client")
return fmt.Errorf("glusterfs: failed to create glusterfs rest client, REST server authentication failed") return fmt.Errorf("failed to create glusterfs rest client, REST server authentication failed")
} }
err = cli.VolumeDelete(volumeID) err = cli.VolumeDelete(volumeID)
if err != nil { if err != nil {
glog.Errorf("glusterfs: error when deleting the volume :%v", err) glog.Errorf("error when deleting the volume :%v", err)
return err return err
} }
glog.V(2).Infof("glusterfs: volume %s deleted successfully", volumeName) glog.V(2).Infof("volume %s deleted successfully", volumeName)
//Deleter takes endpoint and endpointnamespace from pv spec. //Deleter takes endpoint and endpointnamespace from pv spec.
pvSpec := d.spec.Spec pvSpec := d.spec.Spec
var dynamicEndpoint, dynamicNamespace string var dynamicEndpoint, dynamicNamespace string
if pvSpec.ClaimRef == nil { if pvSpec.ClaimRef == nil {
glog.Errorf("glusterfs: ClaimRef is nil") glog.Errorf("ClaimRef is nil")
return fmt.Errorf("glusterfs: ClaimRef is nil") return fmt.Errorf("ClaimRef is nil")
} }
if pvSpec.ClaimRef.Namespace == "" { if pvSpec.ClaimRef.Namespace == "" {
glog.Errorf("glusterfs: namespace is nil") glog.Errorf("namespace is nil")
return fmt.Errorf("glusterfs: namespace is nil") return fmt.Errorf("namespace is nil")
} }
dynamicNamespace = pvSpec.ClaimRef.Namespace dynamicNamespace = pvSpec.ClaimRef.Namespace
if pvSpec.Glusterfs.EndpointsName != "" { if pvSpec.Glusterfs.EndpointsName != "" {
dynamicEndpoint = pvSpec.Glusterfs.EndpointsName dynamicEndpoint = pvSpec.Glusterfs.EndpointsName
} }
glog.V(3).Infof("glusterfs: dynamic namespace and endpoint : [%v/%v]", dynamicNamespace, dynamicEndpoint) glog.V(3).Infof("dynamic namespace and endpoint : [%v/%v]", dynamicNamespace, dynamicEndpoint)
err = d.deleteEndpointService(dynamicNamespace, dynamicEndpoint) err = d.deleteEndpointService(dynamicNamespace, dynamicEndpoint)
if err != nil { if err != nil {
glog.Errorf("glusterfs: error when deleting endpoint/service :%v", err) glog.Errorf("error when deleting endpoint/service :%v", err)
} else { } else {
glog.V(1).Infof("glusterfs: [%v/%v] deleted successfully ", dynamicNamespace, dynamicEndpoint) glog.V(1).Infof("endpoint: %v and service: %v deleted successfully ", dynamicNamespace, dynamicEndpoint)
} }
return nil return nil
} }
@ -669,10 +669,10 @@ func (p *glusterfsVolumeProvisioner) Provision() (*v1.PersistentVolume, error) {
} }
if p.options.PVC.Spec.Selector != nil { if p.options.PVC.Spec.Selector != nil {
glog.V(4).Infof("glusterfs: not able to parse your claim Selector") glog.V(4).Infof("not able to parse your claim Selector")
return nil, fmt.Errorf("glusterfs: not able to parse your claim Selector") return nil, fmt.Errorf("not able to parse your claim Selector")
} }
glog.V(4).Infof("glusterfs: Provision VolumeOptions %v", p.options) glog.V(4).Infof("Provision VolumeOptions %v", p.options)
scName := v1helper.GetPersistentVolumeClaimClass(p.options.PVC) scName := v1helper.GetPersistentVolumeClaimClass(p.options.PVC)
cfg, err := parseClassParameters(p.options.Parameters, p.plugin.host.GetKubeClient()) cfg, err := parseClassParameters(p.options.Parameters, p.plugin.host.GetKubeClient())
if err != nil { if err != nil {
@ -680,29 +680,29 @@ func (p *glusterfsVolumeProvisioner) Provision() (*v1.PersistentVolume, error) {
} }
p.provisionerConfig = *cfg p.provisionerConfig = *cfg
glog.V(4).Infof("glusterfs: creating volume with configuration %+v", p.provisionerConfig) glog.V(4).Infof("creating volume with configuration %+v", p.provisionerConfig)
gidTable, err := p.plugin.getGidTable(scName, cfg.gidMin, cfg.gidMax) gidTable, err := p.plugin.getGidTable(scName, cfg.gidMin, cfg.gidMax)
if err != nil { if err != nil {
return nil, fmt.Errorf("glusterfs: failed to get gidTable: %v", err) return nil, fmt.Errorf("failed to get gidTable: %v", err)
} }
gid, _, err := gidTable.AllocateNext() gid, _, err := gidTable.AllocateNext()
if err != nil { if err != nil {
glog.Errorf("glusterfs: failed to reserve gid from table: %v", err) glog.Errorf("failed to reserve GID from table: %v", err)
return nil, fmt.Errorf("glusterfs: failed to reserve gid from table: %v", err) return nil, fmt.Errorf("failed to reserve GID from table: %v", err)
} }
glog.V(2).Infof("glusterfs: got gid [%d] for PVC %s", gid, p.options.PVC.Name) glog.V(2).Infof("Allocated GID [%d] for PVC %s", gid, p.options.PVC.Name)
glusterfs, sizeGB, err := p.CreateVolume(gid) glusterfs, sizeGB, err := p.CreateVolume(gid)
if err != nil { if err != nil {
if releaseErr := gidTable.Release(gid); releaseErr != nil { if releaseErr := gidTable.Release(gid); releaseErr != nil {
glog.Errorf("glusterfs: error when releasing gid in storageclass: %s", scName) glog.Errorf("error when releasing GID in storageclass: %s", scName)
} }
glog.Errorf("glusterfs: create volume err: %v.", err) glog.Errorf("create volume error: %v.", err)
return nil, fmt.Errorf("glusterfs: create volume error: %v", err) return nil, fmt.Errorf("create volume error: %v", err)
} }
pv := new(v1.PersistentVolume) pv := new(v1.PersistentVolume)
pv.Spec.PersistentVolumeSource.Glusterfs = glusterfs pv.Spec.PersistentVolumeSource.Glusterfs = glusterfs
@ -733,31 +733,31 @@ func (p *glusterfsVolumeProvisioner) CreateVolume(gid int) (r *v1.GlusterfsVolum
capacity := p.options.PVC.Spec.Resources.Requests[v1.ResourceName(v1.ResourceStorage)] capacity := p.options.PVC.Spec.Resources.Requests[v1.ResourceName(v1.ResourceStorage)]
volSizeBytes := capacity.Value() volSizeBytes := capacity.Value()
sz := int(volume.RoundUpSize(volSizeBytes, 1024*1024*1024)) sz := int(volume.RoundUpSize(volSizeBytes, 1024*1024*1024))
glog.V(2).Infof("glusterfs: create volume of size: %d bytes and configuration %+v", volSizeBytes, p.provisionerConfig) glog.V(2).Infof("create volume of size: %d bytes and configuration %+v", volSizeBytes, p.provisionerConfig)
if p.url == "" { if p.url == "" {
glog.Errorf("glusterfs : rest server endpoint is empty") glog.Errorf("REST server endpoint is empty")
return nil, 0, fmt.Errorf("failed to create glusterfs REST client, REST URL is empty") return nil, 0, fmt.Errorf("failed to create glusterfs REST client, REST URL is empty")
} }
cli := gcli.NewClient(p.url, p.user, p.secretValue) cli := gcli.NewClient(p.url, p.user, p.secretValue)
if cli == nil { if cli == nil {
glog.Errorf("glusterfs: failed to create glusterfs rest client") glog.Errorf("failed to create glusterfs rest client")
return nil, 0, fmt.Errorf("failed to create glusterfs REST client, REST server authentication failed") return nil, 0, fmt.Errorf("failed to create glusterfs REST client, REST server authentication failed")
} }
if p.provisionerConfig.clusterID != "" { if p.provisionerConfig.clusterID != "" {
clusterIDs = dstrings.Split(p.clusterID, ",") clusterIDs = dstrings.Split(p.clusterID, ",")
glog.V(4).Infof("glusterfs: provided clusterIDs: %v", clusterIDs) glog.V(4).Infof("provided clusterIDs: %v", clusterIDs)
} }
gid64 := int64(gid) gid64 := int64(gid)
volumeReq := &gapi.VolumeCreateRequest{Size: sz, Clusters: clusterIDs, Gid: gid64, Durability: p.volumeType, GlusterVolumeOptions: p.volumeOptions} volumeReq := &gapi.VolumeCreateRequest{Size: sz, Clusters: clusterIDs, Gid: gid64, Durability: p.volumeType, GlusterVolumeOptions: p.volumeOptions}
volume, err := cli.VolumeCreate(volumeReq) volume, err := cli.VolumeCreate(volumeReq)
if err != nil { if err != nil {
glog.Errorf("glusterfs: error creating volume %v ", err) glog.Errorf("error creating volume %v ", err)
return nil, 0, fmt.Errorf("error creating volume %v", err) return nil, 0, fmt.Errorf("error creating volume %v", err)
} }
glog.V(1).Infof("glusterfs: volume with size: %d and name: %s created", volume.Size, volume.Name) glog.V(1).Infof("volume with size: %d and name: %s created", volume.Size, volume.Name)
dynamicHostIps, err := getClusterNodes(cli, volume.Cluster) dynamicHostIps, err := getClusterNodes(cli, volume.Cluster)
if err != nil { if err != nil {
glog.Errorf("glusterfs: error [%v] when getting cluster nodes for volume %s", err, volume) glog.Errorf("error [%v] when getting cluster nodes for volume %s", err, volume)
return nil, 0, fmt.Errorf("error [%v] when getting cluster nodes for volume %s", err, volume) return nil, 0, fmt.Errorf("error [%v] when getting cluster nodes for volume %s", err, volume)
} }
@ -769,14 +769,14 @@ func (p *glusterfsVolumeProvisioner) CreateVolume(gid int) (r *v1.GlusterfsVolum
epNamespace := p.options.PVC.Namespace epNamespace := p.options.PVC.Namespace
endpoint, service, err := p.createEndpointService(epNamespace, epServiceName, dynamicHostIps, p.options.PVC.Name) endpoint, service, err := p.createEndpointService(epNamespace, epServiceName, dynamicHostIps, p.options.PVC.Name)
if err != nil { if err != nil {
glog.Errorf("glusterfs: failed to create endpoint/service: %v", err) glog.Errorf("failed to create endpoint/service: %v", err)
deleteErr := cli.VolumeDelete(volume.Id) deleteErr := cli.VolumeDelete(volume.Id)
if deleteErr != nil { if deleteErr != nil {
glog.Errorf("glusterfs: error when deleting the volume :%v , manual deletion required", deleteErr) glog.Errorf("error when deleting the volume :%v , manual deletion required", deleteErr)
} }
return nil, 0, fmt.Errorf("failed to create endpoint/service %v", err) return nil, 0, fmt.Errorf("failed to create endpoint/service %v", err)
} }
glog.V(3).Infof("glusterfs: dynamic ep %v and svc : %v ", endpoint, service) glog.V(3).Infof("dynamic ep %v and svc : %v ", endpoint, service)
return &v1.GlusterfsVolumeSource{ return &v1.GlusterfsVolumeSource{
EndpointsName: endpoint.Name, EndpointsName: endpoint.Name,
Path: volume.Name, Path: volume.Name,
@ -805,15 +805,15 @@ func (p *glusterfsVolumeProvisioner) createEndpointService(namespace string, epS
} }
kubeClient := p.plugin.host.GetKubeClient() kubeClient := p.plugin.host.GetKubeClient()
if kubeClient == nil { if kubeClient == nil {
return nil, nil, fmt.Errorf("glusterfs: failed to get kube client when creating endpoint service") return nil, nil, fmt.Errorf("failed to get kube client when creating endpoint service")
} }
_, err = kubeClient.Core().Endpoints(namespace).Create(endpoint) _, err = kubeClient.Core().Endpoints(namespace).Create(endpoint)
if err != nil && errors.IsAlreadyExists(err) { if err != nil && errors.IsAlreadyExists(err) {
glog.V(1).Infof("glusterfs: endpoint [%s] already exist in namespace [%s]", endpoint, namespace) glog.V(1).Infof("endpoint [%s] already exist in namespace [%s]", endpoint, namespace)
err = nil err = nil
} }
if err != nil { if err != nil {
glog.Errorf("glusterfs: failed to create endpoint: %v", err) glog.Errorf("failed to create endpoint: %v", err)
return nil, nil, fmt.Errorf("error creating endpoint: %v", err) return nil, nil, fmt.Errorf("error creating endpoint: %v", err)
} }
service = &v1.Service{ service = &v1.Service{
@ -829,11 +829,11 @@ func (p *glusterfsVolumeProvisioner) createEndpointService(namespace string, epS
{Protocol: "TCP", Port: 1}}}} {Protocol: "TCP", Port: 1}}}}
_, err = kubeClient.Core().Services(namespace).Create(service) _, err = kubeClient.Core().Services(namespace).Create(service)
if err != nil && errors.IsAlreadyExists(err) { if err != nil && errors.IsAlreadyExists(err) {
glog.V(1).Infof("glusterfs: service [%s] already exist in namespace [%s]", service, namespace) glog.V(1).Infof("service [%s] already exist in namespace [%s]", service, namespace)
err = nil err = nil
} }
if err != nil { if err != nil {
glog.Errorf("glusterfs: failed to create service: %v", err) glog.Errorf("failed to create service: %v", err)
return nil, nil, fmt.Errorf("error creating service: %v", err) return nil, nil, fmt.Errorf("error creating service: %v", err)
} }
return endpoint, service, nil return endpoint, service, nil
@ -842,14 +842,14 @@ func (p *glusterfsVolumeProvisioner) createEndpointService(namespace string, epS
func (d *glusterfsVolumeDeleter) deleteEndpointService(namespace string, epServiceName string) (err error) { func (d *glusterfsVolumeDeleter) deleteEndpointService(namespace string, epServiceName string) (err error) {
kubeClient := d.plugin.host.GetKubeClient() kubeClient := d.plugin.host.GetKubeClient()
if kubeClient == nil { if kubeClient == nil {
return fmt.Errorf("glusterfs: failed to get kube client when deleting endpoint service") return fmt.Errorf("failed to get kube client when deleting endpoint service")
} }
err = kubeClient.Core().Services(namespace).Delete(epServiceName, nil) err = kubeClient.Core().Services(namespace).Delete(epServiceName, nil)
if err != nil { if err != nil {
glog.Errorf("glusterfs: error deleting service %s/%s: %v", namespace, epServiceName, err) glog.Errorf("error deleting service %s/%s: %v", namespace, epServiceName, err)
return fmt.Errorf("error deleting service %s/%s: %v", namespace, epServiceName, err) return fmt.Errorf("error deleting service %s/%s: %v", namespace, epServiceName, err)
} }
glog.V(1).Infof("glusterfs: service/endpoint %s/%s deleted successfully", namespace, epServiceName) glog.V(1).Infof("service/endpoint %s/%s deleted successfully", namespace, epServiceName)
return nil return nil
} }
@ -879,7 +879,7 @@ func parseSecret(namespace, secretName string, kubeClient clientset.Interface) (
func getClusterNodes(cli *gcli.Client, cluster string) (dynamicHostIps []string, err error) { func getClusterNodes(cli *gcli.Client, cluster string) (dynamicHostIps []string, err error) {
clusterinfo, err := cli.ClusterInfo(cluster) clusterinfo, err := cli.ClusterInfo(cluster)
if err != nil { if err != nil {
glog.Errorf("glusterfs: failed to get cluster details: %v", err) glog.Errorf("failed to get cluster details: %v", err)
return nil, fmt.Errorf("failed to get cluster details: %v", err) return nil, fmt.Errorf("failed to get cluster details: %v", err)
} }
@ -889,15 +889,15 @@ func getClusterNodes(cli *gcli.Client, cluster string) (dynamicHostIps []string,
for _, node := range clusterinfo.Nodes { for _, node := range clusterinfo.Nodes {
nodei, err := cli.NodeInfo(string(node)) nodei, err := cli.NodeInfo(string(node))
if err != nil { if err != nil {
glog.Errorf("glusterfs: failed to get hostip: %v", err) glog.Errorf(" failed to get hostip: %v", err)
return nil, fmt.Errorf("failed to get hostip: %v", err) return nil, fmt.Errorf("failed to get hostip: %v", err)
} }
ipaddr := dstrings.Join(nodei.NodeAddRequest.Hostnames.Storage, "") ipaddr := dstrings.Join(nodei.NodeAddRequest.Hostnames.Storage, "")
dynamicHostIps = append(dynamicHostIps, ipaddr) dynamicHostIps = append(dynamicHostIps, ipaddr)
} }
glog.V(3).Infof("glusterfs: hostlist :%v", dynamicHostIps) glog.V(3).Infof("hostlist :%v", dynamicHostIps)
if len(dynamicHostIps) == 0 { if len(dynamicHostIps) == 0 {
glog.Errorf("glusterfs: no hosts found: %v", err) glog.Errorf("no hosts found: %v", err)
return nil, fmt.Errorf("no hosts found: %v", err) return nil, fmt.Errorf("no hosts found: %v", err)
} }
return dynamicHostIps, nil return dynamicHostIps, nil
@ -935,25 +935,25 @@ func parseClassParameters(params map[string]string, kubeClient clientset.Interfa
case "gidmin": case "gidmin":
parseGidMin, err := convertGid(v) parseGidMin, err := convertGid(v)
if err != nil { if err != nil {
return nil, fmt.Errorf("glusterfs: invalid value %q for volume plugin %s", k, glusterfsPluginName) return nil, fmt.Errorf("invalid value %q for volume plugin %s", k, glusterfsPluginName)
} }
if parseGidMin < absoluteGidMin { if parseGidMin < absoluteGidMin {
return nil, fmt.Errorf("glusterfs: gidMin must be >= %v", absoluteGidMin) return nil, fmt.Errorf("gidMin must be >= %v", absoluteGidMin)
} }
if parseGidMin > absoluteGidMax { if parseGidMin > absoluteGidMax {
return nil, fmt.Errorf("glusterfs: gidMin must be <= %v", absoluteGidMax) return nil, fmt.Errorf("gidMin must be <= %v", absoluteGidMax)
} }
cfg.gidMin = parseGidMin cfg.gidMin = parseGidMin
case "gidmax": case "gidmax":
parseGidMax, err := convertGid(v) parseGidMax, err := convertGid(v)
if err != nil { if err != nil {
return nil, fmt.Errorf("glusterfs: invalid value %q for volume plugin %s", k, glusterfsPluginName) return nil, fmt.Errorf("invalid value %q for volume plugin %s", k, glusterfsPluginName)
} }
if parseGidMax < absoluteGidMin { if parseGidMax < absoluteGidMin {
return nil, fmt.Errorf("glusterfs: gidMax must be >= %v", absoluteGidMin) return nil, fmt.Errorf("gidMax must be >= %v", absoluteGidMin)
} }
if parseGidMax > absoluteGidMax { if parseGidMax > absoluteGidMax {
return nil, fmt.Errorf("glusterfs: gidMax must be <= %v", absoluteGidMax) return nil, fmt.Errorf("gidMax must be <= %v", absoluteGidMax)
} }
cfg.gidMax = parseGidMax cfg.gidMax = parseGidMax
case "volumetype": case "volumetype":
@ -965,7 +965,7 @@ func parseClassParameters(params map[string]string, kubeClient clientset.Interfa
} }
default: default:
return nil, fmt.Errorf("glusterfs: invalid option %q for volume plugin %s", k, glusterfsPluginName) return nil, fmt.Errorf("invalid option %q for volume plugin %s", k, glusterfsPluginName)
} }
} }