"meta" type descriptions used for code generation

pkg/cloudprovider/providers/gce/cloud/meta/doc.go

@@ -0,0 +1,19 @@
+/*
+Copyright 2017 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 meta contains the meta description of the GCE cloud types to
+// generate code for.
+package meta

pkg/cloudprovider/providers/gce/cloud/meta/key.go

@@ -0,0 +1,96 @@
+/*
+Copyright 2017 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 meta
+
+import (
+	"fmt"
+)
+
+// Key for a GCP resource.
+type Key struct {
+	Name   string
+	Zone   string
+	Region string
+}
+
+// KeyType is the type of the key.
+type KeyType string
+
+const (
+	// Zonal key type.
+	Zonal = "zonal"
+	// Regional key type.
+	Regional = "regional"
+	// Global key type.
+	Global = "global"
+)
+
+// ZonalKey returns the key for a zonal resource.
+func ZonalKey(name, zone string) *Key {
+	return &Key{name, zone, ""}
+}
+
+// RegionalKey returns the key for a regional resource.
+func RegionalKey(name, region string) *Key {
+	return &Key{name, "", region}
+}
+
+// GlobalKey returns the key for a global resource.
+func GlobalKey(name string) *Key {
+	return &Key{name, "", ""}
+}
+
+// Type returns the type of the key.
+func (k *Key) Type() KeyType {
+	switch {
+	case k.Zone != "":
+		return Zonal
+	case k.Region != "":
+		return Regional
+	default:
+		return Global
+	}
+}
+
+// String returns a string representation of the key.
+func (k Key) String() string {
+	switch k.Type() {
+	case Zonal:
+		return fmt.Sprintf("Key{%q, zone: %q}", k.Name, k.Zone)
+	case Regional:
+		return fmt.Sprintf("Key{%q, region: %q}", k.Name, k.Region)
+	default:
+		return fmt.Sprintf("Key{%q}", k.Name)
+	}
+}
+
+// Valid is true if the key is valid.
+func (k *Key) Valid(typeName string) bool {
+	if k.Zone != "" && k.Region != "" {
+		return false
+	}
+	return true
+}
+
+// KeysToMap creates a map[Key]bool from a list of keys.
+func KeysToMap(keys ...Key) map[Key]bool {
+	ret := map[Key]bool{}
+	for _, k := range keys {
+		ret[k] = true
+	}
+	return ret
+}

pkg/cloudprovider/providers/gce/cloud/meta/key_test.go

@@ -0,0 +1,75 @@
+/*
+Copyright 2017 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 meta
+
+import (
+	"testing"
+)
+
+func TestKeyType(t *testing.T) {
+	t.Parallel()
+
+	for _, tc := range []struct {
+		key  *Key
+		want KeyType
+	}{
+		{GlobalKey("abc"), Global},
+		{ZonalKey("abc", "us-central1-b"), Zonal},
+		{RegionalKey("abc", "us-central1"), Regional},
+	} {
+		if tc.key.Type() != tc.want {
+			t.Errorf("key.Type() == %v, want %v", tc.key.Type(), tc.want)
+		}
+	}
+}
+
+func TestKeyString(t *testing.T) {
+	t.Parallel()
+
+	for _, k := range []*Key{
+		GlobalKey("abc"),
+		RegionalKey("abc", "us-central1"),
+		ZonalKey("abc", "us-central1-b"),
+	} {
+		if k.String() == "" {
+			t.Errorf(`k.String() = "", want non-empty`)
+		}
+	}
+}
+
+func TestKeyValid(t *testing.T) {
+	t.Parallel()
+
+	region := "us-central1"
+	zone := "us-central1-b"
+
+	for _, tc := range []struct {
+		key      *Key
+		typeName string
+		want     bool
+	}{
+		// Note: these test cases need to be synchronized with the
+		// actual settings for each type.
+		{GlobalKey("abc"), "UrlMap", true},
+		{&Key{"abc", zone, region}, "UrlMap", false},
+	} {
+		valid := tc.key.Valid(tc.typeName)
+		if valid != tc.want {
+			t.Errorf("key %+v, type %v; key.Valid() = %v, want %v", tc.key, tc.typeName, valid, tc.want)
+		}
+	}
+}

pkg/cloudprovider/providers/gce/cloud/meta/meta.go

@@ -0,0 +1,372 @@
+/*
+Copyright 2017 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 meta
+
+import (
+	"reflect"
+
+	alpha "google.golang.org/api/compute/v0.alpha"
+	beta "google.golang.org/api/compute/v0.beta"
+	ga "google.golang.org/api/compute/v1"
+)
+
+// Version of the API (ga, alpha, beta).
+type Version string
+
+const (
+	// NoGet prevents the Get() method from being generated.
+	NoGet = 1 << iota
+	// NoList prevents the List() method from being generated.
+	NoList = 1 << iota
+	// NoDelete prevents the Delete() method from being generated.
+	NoDelete = 1 << iota
+	// NoInsert prevents the Insert() method from being generated.
+	NoInsert = 1 << iota
+	// CustomOps specifies that an empty interface xxxOps will be generated to
+	// enable custom method calls to be attached to the generated service
+	// interface.
+	CustomOps = 1 << iota
+	// AggregatedList will generated a method for AggregatedList().
+	AggregatedList = 1 << iota
+
+	// ReadOnly specifies that the given resource is read-only and should not
+	// have insert() or delete() methods generated for the wrapper.
+	ReadOnly = NoDelete | NoInsert
+
+	// VersionGA is the API version in compute.v1.
+	VersionGA Version = "ga"
+	// VersionAlpha is the API version in computer.v0.alpha.
+	VersionAlpha Version = "alpha"
+	// VersionBeta is the API version in computer.v0.beta.
+	VersionBeta Version = "beta"
+)
+
+// AllVersions is a list of all versions of the GCE API.
+var AllVersions = []Version{
+	VersionGA,
+	VersionAlpha,
+	VersionBeta,
+}
+
+// AllServices are a list of all the services to generate code for. Keep
+// this list in lexiographical order by object type.
+var AllServices = []*ServiceInfo{
+	&ServiceInfo{
+		Object:      "Address",
+		Service:     "Addresses",
+		Resource:    "addresses",
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&ga.AddressesService{}),
+	},
+	&ServiceInfo{
+		Object:      "Address",
+		Service:     "Addresses",
+		Resource:    "addresses",
+		version:     VersionAlpha,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.AddressesService{}),
+	},
+	&ServiceInfo{
+		Object:      "Address",
+		Service:     "Addresses",
+		Resource:    "addresses",
+		version:     VersionBeta,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&beta.AddressesService{}),
+	},
+	&ServiceInfo{
+		Object:      "Address",
+		Service:     "GlobalAddresses",
+		Resource:    "addresses",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.GlobalAddressesService{}),
+	},
+	&ServiceInfo{
+		Object:      "BackendService",
+		Service:     "BackendServices",
+		Resource:    "backendServices",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.BackendServicesService{}),
+		additionalMethods: []string{
+			"GetHealth",
+			"Update",
+		},
+	},
+	&ServiceInfo{
+		Object:            "BackendService",
+		Service:           "BackendServices",
+		Resource:    "backendServices",
+		version:           VersionAlpha,
+		keyType:           Global,
+		serviceType:       reflect.TypeOf(&alpha.BackendServicesService{}),
+		additionalMethods: []string{"Update"},
+	},
+	&ServiceInfo{
+		Object:      "BackendService",
+		Service:     "RegionBackendServices",
+		Resource:    "backendServices",
+		version:     VersionAlpha,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.RegionBackendServicesService{}),
+		additionalMethods: []string{
+			"GetHealth",
+			"Update",
+		},
+	},
+	&ServiceInfo{
+		Object:      "Disk",
+		Service:     "Disks",
+		Resource:    "disks",
+		keyType:     Zonal,
+		serviceType: reflect.TypeOf(&ga.DisksService{}),
+	},
+	&ServiceInfo{
+		Object:      "Disk",
+		Service:     "Disks",
+		Resource:    "disks",
+		version:     VersionAlpha,
+		keyType:     Zonal,
+		serviceType: reflect.TypeOf(&alpha.DisksService{}),
+	},
+	&ServiceInfo{
+		Object:      "Disk",
+		Service:     "RegionDisks",
+		Resource:    "disks",
+		version:     VersionAlpha,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.DisksService{}),
+	},
+	&ServiceInfo{
+		Object:      "Firewall",
+		Service:     "Firewalls",
+		Resource:    "firewalls",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.FirewallsService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
+	&ServiceInfo{
+		Object:      "ForwardingRule",
+		Service:     "ForwardingRules",
+		Resource:    "forwardingRules",
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&ga.ForwardingRulesService{}),
+	},
+	&ServiceInfo{
+		Object:      "ForwardingRule",
+		Service:     "ForwardingRules",
+		Resource:    "forwardingRules",
+		version:     VersionAlpha,
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&alpha.ForwardingRulesService{}),
+	},
+	&ServiceInfo{
+		Object:      "ForwardingRule",
+		Service:     "GlobalForwardingRules",
+		Resource:    "forwardingRules",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.GlobalForwardingRulesService{}),
+		additionalMethods: []string{
+			"SetTarget",
+		},
+	},
+	&ServiceInfo{
+		Object:      "HealthCheck",
+		Service:     "HealthChecks",
+		Resource:    "healthChecks",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.HealthChecksService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
+	&ServiceInfo{
+		Object:      "HealthCheck",
+		Service:     "HealthChecks",
+		Resource:    "healthChecks",
+		version:     VersionAlpha,
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&alpha.HealthChecksService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
+	&ServiceInfo{
+		Object:      "HttpHealthCheck",
+		Service:     "HttpHealthChecks",
+		Resource:    "httpHealthChecks",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.HttpHealthChecksService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
+	&ServiceInfo{
+		Object:      "HttpsHealthCheck",
+		Service:     "HttpsHealthChecks",
+		Resource:    "httpsHealthChecks",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.HttpsHealthChecksService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
+	&ServiceInfo{
+		Object:      "InstanceGroup",
+		Service:     "InstanceGroups",
+		Resource:    "instanceGroups",
+		keyType:     Zonal,
+		serviceType: reflect.TypeOf(&ga.InstanceGroupsService{}),
+		additionalMethods: []string{
+			"AddInstances",
+			"ListInstances",
+			"RemoveInstances",
+			"SetNamedPorts",
+		},
+	},
+	&ServiceInfo{
+		Object:      "Instance",
+		Service:     "Instances",
+		Resource:    "instances",
+		keyType:     Zonal,
+		serviceType: reflect.TypeOf(&ga.InstancesService{}),
+		additionalMethods: []string{
+			"AttachDisk",
+			"DetachDisk",
+		},
+	},
+	&ServiceInfo{
+		Object:      "Instance",
+		Service:     "Instances",
+		Resource:    "instances",
+		version:     VersionBeta,
+		keyType:     Zonal,
+		serviceType: reflect.TypeOf(&beta.InstancesService{}),
+		additionalMethods: []string{
+			"AttachDisk",
+			"DetachDisk",
+		},
+	},
+	&ServiceInfo{
+		Object:      "Instance",
+		Service:     "Instances",
+		Resource:    "instances",
+		version:     VersionAlpha,
+		keyType:     Zonal,
+		serviceType: reflect.TypeOf(&alpha.InstancesService{}),
+		additionalMethods: []string{
+			"AttachDisk",
+			"DetachDisk",
+			"UpdateNetworkInterface",
+		},
+	},
+	&ServiceInfo{
+		Object:      "NetworkEndpointGroup",
+		Service:     "NetworkEndpointGroups",
+		Resource:    "networkEndpointGroups",
+		version:     VersionAlpha,
+		keyType:     Zonal,
+		serviceType: reflect.TypeOf(&alpha.NetworkEndpointGroupsService{}),
+		additionalMethods: []string{
+			"AttachNetworkEndpoints",
+			"DetachNetworkEndpoints",
+		},
+		options: AggregatedList,
+	},
+	&ServiceInfo{
+		Object:  "Project",
+		Service: "Projects",
+		Resource: "projects",
+		keyType: Global,
+		// Generate only the stub with no methods.
+		options:     NoGet | NoList | NoInsert | NoDelete | CustomOps,
+		serviceType: reflect.TypeOf(&ga.ProjectsService{}),
+	},
+	&ServiceInfo{
+		Object:      "Region",
+		Service:     "Regions",
+		Resource:    "regions",
+		keyType:     Global,
+		options:     ReadOnly,
+		serviceType: reflect.TypeOf(&ga.RegionsService{}),
+	},
+	&ServiceInfo{
+		Object:      "Route",
+		Service:     "Routes",
+		Resource:    "routes",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.RoutesService{}),
+	},
+	&ServiceInfo{
+		Object:      "SslCertificate",
+		Service:     "SslCertificates",
+		Resource:    "sslCertificates",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.SslCertificatesService{}),
+	},
+	&ServiceInfo{
+		Object:      "TargetHttpProxy",
+		Service:     "TargetHttpProxies",
+		Resource:    "targetHttpProxies",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.TargetHttpProxiesService{}),
+		additionalMethods: []string{
+			"SetUrlMap",
+		},
+	},
+	&ServiceInfo{
+		Object:      "TargetHttpsProxy",
+		Service:     "TargetHttpsProxies",
+		Resource:    "targetHttpsProxies",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.TargetHttpsProxiesService{}),
+		additionalMethods: []string{
+			"SetSslCertificates",
+			"SetUrlMap",
+		},
+	},
+	&ServiceInfo{
+		Object:      "TargetPool",
+		Service:     "TargetPools",
+		Resource:    "targetPools",
+		keyType:     Regional,
+		serviceType: reflect.TypeOf(&ga.TargetPoolsService{}),
+		additionalMethods: []string{
+			"AddInstance",
+			"RemoveInstance",
+		},
+	},
+	&ServiceInfo{
+		Object:      "UrlMap",
+		Service:     "UrlMaps",
+		Resource:    "urlMaps",
+		keyType:     Global,
+		serviceType: reflect.TypeOf(&ga.UrlMapsService{}),
+		additionalMethods: []string{
+			"Update",
+		},
+	},
+	&ServiceInfo{
+		Object:      "Zone",
+		Service:     "Zones",
+		Resource:    "zones",
+		keyType:     Global,
+		options:     ReadOnly,
+		serviceType: reflect.TypeOf(&ga.ZonesService{}),
+	},
+}

pkg/cloudprovider/providers/gce/cloud/meta/method.go

@@ -0,0 +1,241 @@
+/*
+Copyright 2017 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 meta
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/golang/glog"
+)
+
+func newArg(t reflect.Type) *arg {
+	ret := &arg{}
+
+	// Dereference the pointer types to get at the underlying concrete type.
+Loop:
+	for {
+		switch t.Kind() {
+		case reflect.Ptr:
+			ret.numPtr++
+			t = t.Elem()
+		default:
+			ret.pkg = t.PkgPath()
+			ret.typeName += t.Name()
+			break Loop
+		}
+	}
+	return ret
+}
+
+type arg struct {
+	pkg, typeName string
+	numPtr        int
+}
+
+func (a *arg) normalizedPkg() string {
+	if a.pkg == "" {
+		return ""
+	}
+
+	// Strip the repo.../vendor/ prefix from the package path if present.
+	parts := strings.Split(a.pkg, "/")
+	// Remove vendor prefix.
+	for i := 0; i < len(parts); i++ {
+		if parts[i] == "vendor" {
+			parts = parts[i+1:]
+			break
+		}
+	}
+	switch strings.Join(parts, "/") {
+	case "google.golang.org/api/compute/v1":
+		return "ga."
+	case "google.golang.org/api/compute/v0.alpha":
+		return "alpha."
+	case "google.golang.org/api/compute/v0.beta":
+		return "beta."
+	default:
+		panic(fmt.Errorf("unhandled package %q", a.pkg))
+	}
+}
+
+func (a *arg) String() string {
+	var ret string
+	for i := 0; i < a.numPtr; i++ {
+		ret += "*"
+	}
+	ret += a.normalizedPkg()
+	ret += a.typeName
+	return ret
+}
+
+// newMethod returns a newly initialized method.
+func newMethod(s *ServiceInfo, m reflect.Method) *Method {
+	ret := &Method{s, m, ""}
+	ret.init()
+	return ret
+}
+
+// Method is used to generate the calling code non-standard methods.
+type Method struct {
+	*ServiceInfo
+	m reflect.Method
+
+	ReturnType string
+}
+
+// argsSkip is the number of arguments to skip when generating the
+// synthesized method.
+func (mr *Method) argsSkip() int {
+	switch mr.keyType {
+	case Zonal:
+		return 4
+	case Regional:
+		return 4
+	case Global:
+		return 3
+	}
+	panic(fmt.Errorf("invalid KeyType %v", mr.keyType))
+}
+
+// args return a list of arguments to the method, skipping the first skip
+// elements. If nameArgs is true, then the arguments will include a generated
+// parameter name (arg<N>). prefix will be added to the parameters.
+func (mr *Method) args(skip int, nameArgs bool, prefix []string) []string {
+	var args []*arg
+	fType := mr.m.Func.Type()
+	for i := 0; i < fType.NumIn(); i++ {
+		t := fType.In(i)
+		args = append(args, newArg(t))
+	}
+
+	var a []string
+	for i := skip; i < fType.NumIn(); i++ {
+		if nameArgs {
+			a = append(a, fmt.Sprintf("arg%d %s", i-skip, args[i]))
+		} else {
+			a = append(a, args[i].String())
+		}
+	}
+	return append(prefix, a...)
+}
+
+func (mr *Method) init() {
+	fType := mr.m.Func.Type()
+	if fType.NumIn() < mr.argsSkip() {
+		err := fmt.Errorf("method %q.%q, arity = %d which is less than required (< %d)",
+			mr.Service, mr.Name(), fType.NumIn(), mr.argsSkip())
+		panic(err)
+	}
+	// Skipped args should all be string (they will be projectID, zone, region etc).
+	for i := 1; i < mr.argsSkip(); i++ {
+		if fType.In(i).Kind() != reflect.String {
+			panic(fmt.Errorf("method %q.%q: skipped args can only be strings", mr.Service, mr.Name()))
+		}
+	}
+	// Return of the method must return a single value of type *xxxCall.
+	if fType.NumOut() != 1 || fType.Out(0).Kind() != reflect.Ptr || !strings.HasSuffix(fType.Out(0).Elem().Name(), "Call") {
+		panic(fmt.Errorf("method %q.%q: generator only supports methods returning an *xxxCall object",
+			mr.Service, mr.Name()))
+	}
+	returnType := fType.Out(0)
+	returnTypeName := fType.Out(0).Elem().Name()
+	// xxxCall must have a Do() method.
+	doMethod, ok := returnType.MethodByName("Do")
+	if !ok {
+		panic(fmt.Errorf("method %q.%q: return type %q does not have a Do() method",
+			mr.Service, mr.Name(), returnTypeName))
+	}
+	// Do() method must return (*T, error).
+	switch doMethod.Func.Type().NumOut() {
+	case 2:
+		glog.Infof("Method %q.%q: return type %q of Do() = %v, %v",
+			mr.Service, mr.Name(), returnTypeName, doMethod.Func.Type().Out(0), doMethod.Func.Type().Out(1))
+		out0 := doMethod.Func.Type().Out(0)
+		if out0.Kind() != reflect.Ptr {
+			panic(fmt.Errorf("method %q.%q: return type %q of Do() = S, _; S must be pointer type (%v)",
+				mr.Service, mr.Name(), returnTypeName, out0))
+		}
+		mr.ReturnType = out0.Elem().Name()
+		if out0.Elem().Name() == "Operation" {
+			glog.Infof("Method %q.%q is an *Operation", mr.Service, mr.Name())
+		} else {
+			glog.Infof("Method %q.%q returns %v", mr.Service, mr.Name(), out0)
+		}
+		// Second argument must be "error".
+		if doMethod.Func.Type().Out(1).Name() != "error" {
+			panic(fmt.Errorf("method %q.%q: return type %q of Do() = S, T; T must be 'error'",
+				mr.Service, mr.Name(), returnTypeName))
+		}
+		break
+	default:
+		panic(fmt.Errorf("method %q.%q: %q Do() return type is not handled by the generator",
+			mr.Service, mr.Name(), returnTypeName))
+	}
+}
+
+func (mr *Method) Name() string {
+	return mr.m.Name
+}
+
+func (mr *Method) CallArgs() string {
+	var args []string
+	for i := mr.argsSkip(); i < mr.m.Func.Type().NumIn(); i++ {
+		args = append(args, fmt.Sprintf("arg%d", i-mr.argsSkip()))
+	}
+	if len(args) == 0 {
+		return ""
+	}
+	return fmt.Sprintf(", %s", strings.Join(args, ", "))
+}
+
+func (mr *Method) MockHookName() string {
+	return mr.m.Name + "Hook"
+}
+
+func (mr *Method) MockHook() string {
+	args := mr.args(mr.argsSkip(), false, []string{
+		fmt.Sprintf("*%s", mr.MockWrapType()),
+		"context.Context",
+		"meta.Key",
+	})
+	if mr.ReturnType == "Operation" {
+		return fmt.Sprintf("%v func(%v) error", mr.MockHookName(), strings.Join(args, ", "))
+	}
+	return fmt.Sprintf("%v func(%v) (*%v.%v, error)", mr.MockHookName(), strings.Join(args, ", "), mr.Version(), mr.ReturnType)
+}
+
+func (mr *Method) FcnArgs() string {
+	args := mr.args(mr.argsSkip(), true, []string{
+		"ctx context.Context",
+		"key meta.Key",
+	})
+
+	if mr.ReturnType == "Operation" {
+		return fmt.Sprintf("%v(%v) error", mr.m.Name, strings.Join(args, ", "))
+	}
+	return fmt.Sprintf("%v(%v) (*%v.%v, error)", mr.m.Name, strings.Join(args, ", "), mr.Version(), mr.ReturnType)
+}
+
+func (mr *Method) InterfaceFunc() string {
+	args := mr.args(mr.argsSkip(), false, []string{"context.Context", "meta.Key"})
+	if mr.ReturnType == "Operation" {
+		return fmt.Sprintf("%v(%v) error", mr.m.Name, strings.Join(args, ", "))
+	}
+	return fmt.Sprintf("%v(%v) (*%v.%v, error)", mr.m.Name, strings.Join(args, ", "), mr.Version(), mr.ReturnType)
+}

pkg/cloudprovider/providers/gce/cloud/meta/service.go

@@ -0,0 +1,273 @@
+/*
+Copyright 2017 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 meta
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+)
+
+// ServiceInfo defines the entry for a Service that code will be generated for.
+type ServiceInfo struct {
+	// Object is the Go name of the object type that the service deals
+	// with. Example: "ForwardingRule".
+	Object string
+	// Service is the Go name of the service struct i.e. where the methods
+	// are defined. Examples: "GlobalForwardingRules".
+	Service string
+	// Resource is the plural noun of the resource in the compute API URL (e.g.
+	// "forwardingRules").
+	Resource string
+	// version if unspecified will be assumed to be VersionGA.
+	version     Version
+	keyType     KeyType
+	serviceType reflect.Type
+
+	additionalMethods   []string
+	options             int
+	aggregatedListField string
+}
+
+// Version returns the version of the Service, defaulting to GA if APIVersion
+// is empty.
+func (i *ServiceInfo) Version() Version {
+	if i.version == "" {
+		return VersionGA
+	}
+	return i.version
+}
+
+// VersionTitle returns the capitalized golang CamelCase name for the version.
+func (i *ServiceInfo) VersionTitle() string {
+	switch i.Version() {
+	case VersionGA:
+		return "GA"
+	case VersionAlpha:
+		return "Alpha"
+	case VersionBeta:
+		return "Beta"
+	}
+	panic(fmt.Errorf("invalid version %q", i.Version()))
+}
+
+// WrapType is the name of the wrapper service type.
+func (i *ServiceInfo) WrapType() string {
+	switch i.Version() {
+	case VersionGA:
+		return i.Service
+	case VersionAlpha:
+		return "Alpha" + i.Service
+	case VersionBeta:
+		return "Beta" + i.Service
+	}
+	return "Invalid"
+}
+
+// WrapTypeOps is the name of the additional operations type.
+func (i *ServiceInfo) WrapTypeOps() string {
+	return i.WrapType() + "Ops"
+}
+
+// FQObjectType is fully qualified name of the object (e.g. compute.Instance).
+func (i *ServiceInfo) FQObjectType() string {
+	return fmt.Sprintf("%v.%v", i.Version(), i.Object)
+}
+
+// ObjectListType is the compute List type for the object (contains Items field).
+func (i *ServiceInfo) ObjectListType() string {
+	return fmt.Sprintf("%v.%vList", i.Version(), i.Object)
+}
+
+// ObjectAggregatedListType is the compute List type for the object (contains Items field).
+func (i *ServiceInfo) ObjectAggregatedListType() string {
+	return fmt.Sprintf("%v.%vAggregatedList", i.Version(), i.Object)
+}
+
+// MockWrapType is the name of the concrete mock for this type.
+func (i *ServiceInfo) MockWrapType() string {
+	return "Mock" + i.WrapType()
+}
+
+// MockField is the name of the field in the mock struct.
+func (i *ServiceInfo) MockField() string {
+	return "Mock" + i.WrapType()
+}
+
+// GCEWrapType is the name of the GCE wrapper type.
+func (i *ServiceInfo) GCEWrapType() string {
+	return "GCE" + i.WrapType()
+}
+
+// Field is the name of the GCE struct.
+func (i *ServiceInfo) Field() string {
+	return "gce" + i.WrapType()
+}
+
+// Methods returns a list of additional methods to generate code for.
+func (i *ServiceInfo) Methods() []*Method {
+	methods := map[string]bool{}
+	for _, m := range i.additionalMethods {
+		methods[m] = true
+	}
+
+	var ret []*Method
+	for j := 0; j < i.serviceType.NumMethod(); j++ {
+		m := i.serviceType.Method(j)
+		if _, ok := methods[m.Name]; !ok {
+			continue
+		}
+		ret = append(ret, newMethod(i, m))
+		methods[m.Name] = false
+	}
+
+	for k, b := range methods {
+		if b {
+			panic(fmt.Errorf("method %q was not found in service %q", k, i.Service))
+		}
+	}
+
+	return ret
+}
+
+// KeyIsGlobal is true if the key is global.
+func (i *ServiceInfo) KeyIsGlobal() bool {
+	return i.keyType == Global
+}
+
+// KeyIsRegional is true if the key is regional.
+func (i *ServiceInfo) KeyIsRegional() bool {
+	return i.keyType == Regional
+}
+
+// KeyIsZonal is true if the key is zonal.
+func (i *ServiceInfo) KeyIsZonal() bool {
+	return i.keyType == Zonal
+}
+
+// MakeKey returns the call used to create the appropriate key type.
+func (i *ServiceInfo) MakeKey(name, location string) string {
+	switch i.keyType {
+	case Global:
+		return fmt.Sprintf("GlobalKey(%q)", name)
+	case Regional:
+		return fmt.Sprintf("RegionalKey(%q, %q)", name, location)
+	case Zonal:
+		return fmt.Sprintf("ZonalKey(%q, %q)", name, location)
+	}
+	return "Invalid"
+}
+
+// GenerateGet is true if the method is to be generated.
+func (i *ServiceInfo) GenerateGet() bool {
+	return i.options&NoGet == 0
+}
+
+// GenerateList is true if the method is to be generated.
+func (i *ServiceInfo) GenerateList() bool {
+	return i.options&NoList == 0
+}
+
+// GenerateDelete is true if the method is to be generated.
+func (i *ServiceInfo) GenerateDelete() bool {
+	return i.options&NoDelete == 0
+}
+
+// GenerateInsert is true if the method is to be generated.
+func (i *ServiceInfo) GenerateInsert() bool {
+	return i.options&NoInsert == 0
+}
+
+// GenerateCustomOps is true if we should generated a xxxOps interface for
+// adding additional methods to the generated interface.
+func (i *ServiceInfo) GenerateCustomOps() bool {
+	return i.options&CustomOps != 0
+}
+
+// AggregatedList is true if the method is to be generated.
+func (i *ServiceInfo) AggregatedList() bool {
+	return i.options&AggregatedList != 0
+}
+
+// AggregatedListField is the name of the field used for the aggregated list
+// call. This is typically the same as the name of the service, but can be
+// customized by setting the aggregatedListField field.
+func (i *ServiceInfo) AggregatedListField() string {
+	if i.aggregatedListField == "" {
+		return i.Service
+	}
+	return i.aggregatedListField
+}
+
+// ServiceGroup is a grouping of the same service but at different API versions.
+type ServiceGroup struct {
+	Alpha *ServiceInfo
+	Beta  *ServiceInfo
+	GA    *ServiceInfo
+}
+
+func (sg *ServiceGroup) Service() string {
+	switch {
+	case sg.GA != nil:
+		return sg.GA.Service
+	case sg.Alpha != nil:
+		return sg.Alpha.Service
+	case sg.Beta != nil:
+		return sg.Beta.Service
+	default:
+		panic(errors.New("service group is empty"))
+	}
+}
+
+func (sg *ServiceGroup) HasGA() bool {
+	return sg.GA != nil
+}
+
+func (sg *ServiceGroup) HasAlpha() bool {
+	return sg.Alpha != nil
+}
+
+func (sg *ServiceGroup) HasBeta() bool {
+	return sg.Beta != nil
+}
+
+// groupServices together by version.
+func groupServices(services []*ServiceInfo) map[string]*ServiceGroup {
+	ret := map[string]*ServiceGroup{}
+	for _, si := range services {
+		if _, ok := ret[si.Service]; !ok {
+			ret[si.Service] = &ServiceGroup{}
+		}
+		group := ret[si.Service]
+		switch si.Version() {
+		case VersionAlpha:
+			group.Alpha = si
+		case VersionBeta:
+			group.Beta = si
+		case VersionGA:
+			group.GA = si
+		}
+	}
+	return ret
+}
+
+// AllServicesByGroup is a map of service name to ServicesGroup.
+var AllServicesByGroup map[string]*ServiceGroup
+
+func init() {
+	AllServicesByGroup = groupServices(AllServices)
+}