Regional PD Implementation, added unit tests for common utilities. When

picking random zones just pick 1 zone randomly and the others are picked
consecutively

Author: davidz627

cmd/main.go

@@ -35,7 +35,6 @@ func init() {
 var (
 	endpoint      = flag.String("endpoint", "unix:/tmp/csi.sock", "CSI endpoint")
 	driverName    = flag.String("drivername", "com.google.csi.gcepd", "name of the driver")
-	nodeID        = flag.String("nodeid", "", "node id")
 	vendorVersion string
 )
 
@@ -50,7 +49,7 @@ func handle() {
 	if vendorVersion == "" {
 		glog.Fatalf("vendorVersion must be set at compile time")
 	}
-	glog.Infof("Driver vendor version %v", vendorVersion)
+	glog.V(4).Infof("Driver vendor version %v", vendorVersion)
 
 	gceDriver := driver.GetGCEDriver()
 
@@ -68,7 +67,7 @@ func handle() {
 		glog.Fatalf("Failed to set up metadata service: %v", err)
 	}
 
-	err = gceDriver.SetupGCEDriver(cloudProvider, mounter, deviceUtils, ms, *driverName, *nodeID, vendorVersion)
+	err = gceDriver.SetupGCEDriver(cloudProvider, mounter, deviceUtils, ms, *driverName, vendorVersion)
 	if err != nil {
 		glog.Fatalf("Failed to initialize GCE CSI Driver: %v", err)
 	}

pkg/common/constants.go

@@ -18,8 +18,8 @@ package common
 
 const (
 	// Keys for Storage Class Parameters
-	ParameterKeyZone = "zone"
-	ParameterKeyType = "type"
+	ParameterKeyType            = "type"
+	ParameterKeyReplicationType = "replication-type"
 
 	// Keys for Topology. This key will be shared amonst drivers from GCP
 	TopologyKeyZone = "com.google.topology/zone"

pkg/common/utils.go

@@ -19,6 +19,25 @@ package common
 import (
 	"fmt"
 	"strings"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta"
+)
+
+const (
+	// Volume ID Expected Format
+	// "projects/{projectName}/zones/{zoneName}/disks/{diskName}"
+	// "projects/{projectName}/regions/{regionName}/disks/{diskName}"
+	volIDToplogyKey    = 2
+	volIDToplogyValue  = 3
+	volIDDiskNameValue = 5
+	volIDTotalElements = 6
+
+	// Node ID Expected Format
+	// "{zoneName}/{instanceName}"
+	nodeIDZoneValue     = 0
+	nodeIDNameValue     = 1
+	nodeIDTotalElements = 2
 )
 
 func BytesToGb(bytes int64) int64 {
@@ -31,14 +50,43 @@ func GbToBytes(Gb int64) int64 {
 	return Gb * 1024 * 1024 * 1024
 }
 
-func SplitZoneNameId(id string) (string, string, error) {
+func VolumeIDToKey(id string) (*meta.Key, error) {
+	splitId := strings.Split(id, "/")
+	if len(splitId) != volIDTotalElements {
+		return nil, fmt.Errorf("failed to get id components. Expected projects/{project}/zones/{zone}/disks/{name}. Got: %s", id)
+	}
+	if splitId[volIDToplogyKey] == "zones" {
+		return meta.ZonalKey(splitId[volIDDiskNameValue], splitId[volIDToplogyValue]), nil
+	} else if splitId[volIDToplogyKey] == "regions" {
+		return meta.RegionalKey(splitId[volIDDiskNameValue], splitId[volIDToplogyValue]), nil
+	} else {
+		return nil, fmt.Errorf("could not get id components, expected either zones or regions, got: %v", splitId[volIDToplogyKey])
+	}
+}
+
+func NodeIDToZoneAndName(id string) (string, string, error) {
 	splitId := strings.Split(id, "/")
-	if len(splitId) != 2 {
-		return "", "", fmt.Errorf("Failed to get id components. Expected {zone}/{name}. Got: %s", id)
+	if len(splitId) != nodeIDTotalElements {
+		return "", "", fmt.Errorf("failed to get id components. expected {zone}/{name}. Got: %s", id)
 	}
-	return splitId[0], splitId[1], nil
+	return splitId[nodeIDZoneValue], splitId[nodeIDNameValue], nil
 }
 
-func CombineVolumeId(zone, name string) string {
-	return fmt.Sprintf("%s/%s", zone, name)
+func GetRegionFromZones(zones []string) (string, error) {
+	regions := sets.String{}
+	if len(zones) < 1 {
+		return "", fmt.Errorf("no zones specified")
+	}
+	for _, zone := range zones {
+		// Zone expected format {locale}-{region}-{zone}
+		splitZone := strings.Split(zone, "-")
+		if len(splitZone) != 3 {
+			return "", fmt.Errorf("zone in unexpected format, expected: {locale}-{region}-{zone}, got: %v", zone)
+		}
+		regions.Insert(strings.Join(splitZone[0:2], "-"))
+	}
+	if regions.Len() != 1 {
+		return "", fmt.Errorf("multiple or no regions gotten from zones, got: %v", regions)
+	}
+	return regions.UnsortedList()[0], nil
 }

pkg/common/utils_test.go

@@ -0,0 +1,249 @@
+/*
+Copyright 2018 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 common
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta"
+)
+
+const (
+	volIDZoneFmt   = "projects/%s/zones/%s/disks/%s"
+	volIDRegionFmt = "projects/%s/regions/%s/disks/%s"
+	nodeIDFmt      = "%s/%s"
+)
+
+func TestBytesToGb(t *testing.T) {
+	testCases := []struct {
+		name  string
+		bytes int64
+		expGB int64
+	}{
+		{
+			name:  "normal 5gb",
+			bytes: 5368709120,
+			expGB: 5,
+		},
+		{
+			name:  "slightly less than 5gb",
+			bytes: 5368709119,
+			expGB: 4,
+		},
+		{
+			name:  "slightly more than 5gb",
+			bytes: 5368709121,
+			expGB: 5,
+		},
+		{
+			name:  "zero",
+			bytes: 0,
+			expGB: 0,
+		},
+	}
+	for _, tc := range testCases {
+		t.Logf("test case: %s", tc.name)
+		gotGB := BytesToGb(tc.bytes)
+
+		if gotGB != tc.expGB {
+			t.Errorf("got GB %v, expected %v", gotGB, tc.expGB)
+		}
+
+	}
+}
+
+func TestGbToBytes(t *testing.T) {
+	testCases := []struct {
+		name     string
+		gb       int64
+		expBytes int64
+	}{
+		{
+			name:     "5Gb",
+			gb:       5,
+			expBytes: 5368709120,
+		},
+		{
+			name:     "0gb",
+			gb:       0,
+			expBytes: 0,
+		},
+		{
+			name:     "1gb",
+			gb:       1,
+			expBytes: 1024 * 1024 * 1024,
+		},
+	}
+	for _, tc := range testCases {
+		t.Logf("test case: %s", tc.name)
+		gotBytes := GbToBytes(tc.gb)
+		if gotBytes != tc.expBytes {
+			t.Errorf("got bytes: %v, expected: %v", gotBytes, tc.expBytes)
+		}
+
+	}
+}
+
+func TestVolumeIDToKey(t *testing.T) {
+	testName := "test-name"
+	testZone := "test-zone"
+	testProject := "test-project"
+	testRegion := "test-region"
+
+	testCases := []struct {
+		name   string
+		volID  string
+		expKey *meta.Key
+		expErr bool
+	}{
+		{
+			name:   "normal zonal",
+			volID:  fmt.Sprintf(volIDZoneFmt, testProject, testZone, testName),
+			expKey: meta.ZonalKey(testName, testZone),
+		},
+		{
+			name:   "normal regional",
+			volID:  fmt.Sprintf(volIDRegionFmt, testProject, testRegion, testName),
+			expKey: meta.RegionalKey(testName, testRegion),
+		},
+		{
+			name:   "malformed",
+			volID:  "wrong",
+			expErr: true,
+		},
+		{
+			name:   "malformed but right length",
+			volID:  "this/is/wrong/but/right/num",
+			expErr: true,
+		},
+	}
+	for _, tc := range testCases {
+		t.Logf("test case: %s", tc.name)
+		gotKey, err := VolumeIDToKey(tc.volID)
+		if err == nil && tc.expErr {
+			t.Errorf("Expected error but got none")
+		}
+		if err != nil {
+			if !tc.expErr {
+				t.Errorf("Did not expect error but got: %v", err)
+			}
+			continue
+		}
+
+		if !reflect.DeepEqual(gotKey, tc.expKey) {
+			t.Errorf("Got key %v, but expected %v, from volume ID %v", gotKey, tc.expKey, tc.volID)
+		}
+	}
+
+}
+
+func TestNodeIDToZoneAndName(t *testing.T) {
+	testName := "test-name"
+	testZone := "test-zone"
+
+	testCases := []struct {
+		name    string
+		nodeID  string
+		expZone string
+		expName string
+		expErr  bool
+	}{
+		{
+			name:    "normal",
+			nodeID:  fmt.Sprintf(nodeIDFmt, testZone, testName),
+			expZone: testZone,
+			expName: testName,
+		},
+		{
+			name:   "malformed",
+			nodeID: "wrong",
+			expErr: true,
+		},
+	}
+	for _, tc := range testCases {
+		t.Logf("test case: %s", tc.name)
+		zone, name, err := NodeIDToZoneAndName(tc.nodeID)
+		if err == nil && tc.expErr {
+			t.Errorf("Expected error but got none")
+		}
+		if err != nil {
+			if !tc.expErr {
+				t.Errorf("Did not expect error but got: %v", err)
+			}
+			continue
+		}
+
+		if !(zone == tc.expZone && name == tc.expName) {
+			t.Errorf("got wrong zone/name %s/%s, expected %s/%s", zone, name, tc.expZone, tc.expName)
+		}
+
+	}
+}
+
+func TestGetRegionFromZones(t *testing.T) {
+	testCases := []struct {
+		name      string
+		zones     []string
+		expRegion string
+		expErr    bool
+	}{
+		{
+			name:      "single zone success",
+			zones:     []string{"us-central1-c"},
+			expRegion: "us-central1",
+		},
+		{
+			name:      "multi zone success",
+			zones:     []string{"us-central1-b", "us-central1-c"},
+			expRegion: "us-central1",
+		},
+		{
+			name:   "multi different zone fail",
+			zones:  []string{"us-central1-c", "us-asia1-b"},
+			expErr: true,
+		},
+		{
+			name:   "empty zones",
+			expErr: true,
+		},
+		{
+			name:   "malformed zone",
+			zones:  []string{"blah/blooh"},
+			expErr: true,
+		},
+	}
+	for _, tc := range testCases {
+		t.Logf("test case: %s", tc.name)
+		region, err := GetRegionFromZones(tc.zones)
+		if err == nil && tc.expErr {
+			t.Errorf("Expected error but got none")
+		}
+		if err != nil {
+			if !tc.expErr {
+				t.Errorf("Did not expect error but got: %v", err)
+			}
+			continue
+		}
+
+		if region != tc.expRegion {
+			t.Errorf("Got region: %v, expected: %v", region, tc.expRegion)
+		}
+
+	}
+}