From 6894e3d32bc9990c82b0681aff280e0f9b844db3 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:21:53 -0800 Subject: [PATCH 01/18] Support utilities --- .../providers/gce/cloud/utils.go | 167 +++++++++++++++ .../providers/gce/cloud/utils_test.go | 197 ++++++++++++++++++ 2 files changed, 364 insertions(+) create mode 100644 pkg/cloudprovider/providers/gce/cloud/utils.go create mode 100644 pkg/cloudprovider/providers/gce/cloud/utils_test.go diff --git a/pkg/cloudprovider/providers/gce/cloud/utils.go b/pkg/cloudprovider/providers/gce/cloud/utils.go new file mode 100644 index 00000000000..dd4a07cfd05 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/utils.go @@ -0,0 +1,167 @@ +/* +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 cloud + +import ( + "encoding/json" + "fmt" + "strings" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" +) + +const ( + gaPrefix = "https://www.googleapis.com/compute/v1/" + alphaPrefix = "https://www.googleapis.com/compute/alpha/" + betaPrefix = "https://www.googleapis.com/compute/beta/" +) + +var ( + allPrefixes = []string{gaPrefix, alphaPrefix, betaPrefix} +) + +// ResourceID identifies a GCE resource as parsed from compute resource URL. +type ResourceID struct { + ProjectID string + Resource string + Key *meta.Key +} + +// Equal returns true if two resource IDs are equal. +func (r *ResourceID) Equal(other *ResourceID) bool { + if r.ProjectID != other.ProjectID || r.Resource != other.Resource { + return false + } + if r.Key != nil && other.Key != nil { + return *r.Key == *other.Key + } + if r.Key == nil && other.Key == nil { + return true + } + return false +} + +// ParseResourceURL parses resource URLs of the following formats: +// +// projects//global// +// projects//regions/// +// projects//zones/// +// [https://www.googleapis.com/compute/]/projects//global// +// [https://www.googleapis.com/compute/]/projects//regions/// +// [https://www.googleapis.com/compute/]/projects//zones/// +func ParseResourceURL(url string) (*ResourceID, error) { + errNotValid := fmt.Errorf("%q is not a valid resource URL", url) + + // Remove the "https://..." prefix if present + for _, prefix := range allPrefixes { + if strings.HasPrefix(url, prefix) { + if len(url) < len(prefix) { + return nil, errNotValid + } + url = url[len(prefix):] + break + } + } + + parts := strings.Split(url, "/") + if len(parts) < 2 || parts[0] != "projects" { + return nil, errNotValid + } + + ret := &ResourceID{ProjectID: parts[1]} + if len(parts) == 2 { + ret.Resource = "projects" + return ret, nil + } + + if len(parts) < 4 { + return nil, errNotValid + } + + if len(parts) == 4 { + switch parts[2] { + case "regions": + ret.Resource = "regions" + ret.Key = meta.GlobalKey(parts[3]) + return ret, nil + case "zones": + ret.Resource = "zones" + ret.Key = meta.GlobalKey(parts[3]) + return ret, nil + default: + return nil, errNotValid + } + } + + switch parts[2] { + case "global": + if len(parts) != 5 { + return nil, errNotValid + } + ret.Resource = parts[3] + ret.Key = meta.GlobalKey(parts[4]) + return ret, nil + case "regions": + if len(parts) != 6 { + return nil, errNotValid + } + ret.Resource = parts[4] + ret.Key = meta.RegionalKey(parts[5], parts[3]) + return ret, nil + case "zones": + if len(parts) != 6 { + return nil, errNotValid + } + ret.Resource = parts[4] + ret.Key = meta.ZonalKey(parts[5], parts[3]) + return ret, nil + } + return nil, errNotValid +} + +func copyViaJSON(dest, src interface{}) error { + bytes, err := json.Marshal(src) + if err != nil { + return err + } + return json.Unmarshal(bytes, dest) +} + +// SelfLink returns the self link URL for the given object. +func SelfLink(ver meta.Version, project, resource string, key meta.Key) string { + var prefix string + switch ver { + case meta.VersionAlpha: + prefix = alphaPrefix + case meta.VersionBeta: + prefix = betaPrefix + case meta.VersionGA: + prefix = gaPrefix + default: + prefix = "invalid-prefix" + } + + switch key.Type() { + case meta.Zonal: + return fmt.Sprintf("%sprojects/%s/zones/%s/%s/%s", prefix, project, key.Zone, resource, key.Name) + case meta.Regional: + return fmt.Sprintf("%sprojects/%s/regions/%s/%s/%s", prefix, project, key.Region, resource, key.Name) + case meta.Global: + return fmt.Sprintf("%sprojects/%s/%s/%s", prefix, project, resource, key.Name) + } + return "invalid-self-link" +} diff --git a/pkg/cloudprovider/providers/gce/cloud/utils_test.go b/pkg/cloudprovider/providers/gce/cloud/utils_test.go new file mode 100644 index 00000000000..823c8e73c88 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/utils_test.go @@ -0,0 +1,197 @@ +/* +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 cloud + +import ( + "errors" + "testing" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" +) + +func TestParseResourceURL(t *testing.T) { + t.Parallel() + + for _, tc := range []struct { + in string + r *ResourceID + }{ + { + "https://www.googleapis.com/compute/v1/projects/some-gce-project", + &ResourceID{"some-gce-project", "projects", nil}, + }, + { + "https://www.googleapis.com/compute/v1/projects/some-gce-project/regions/us-central1", + &ResourceID{"some-gce-project", "regions", meta.GlobalKey("us-central1")}, + }, + { + "https://www.googleapis.com/compute/v1/projects/some-gce-project/zones/us-central1-b", + &ResourceID{"some-gce-project", "zones", meta.GlobalKey("us-central1-b")}, + }, + { + "https://www.googleapis.com/compute/v1/projects/some-gce-project/global/operations/operation-1513289952196-56054460af5a0-b1dae0c3-9bbf9dbf", + &ResourceID{"some-gce-project", "operations", meta.GlobalKey("operation-1513289952196-56054460af5a0-b1dae0c3-9bbf9dbf")}, + }, + { + "https://www.googleapis.com/compute/alpha/projects/some-gce-project/regions/us-central1/addresses/my-address", + &ResourceID{"some-gce-project", "addresses", meta.RegionalKey("my-address", "us-central1")}, + }, + { + "https://www.googleapis.com/compute/v1/projects/some-gce-project/zones/us-central1-c/instances/instance-1", + &ResourceID{"some-gce-project", "instances", meta.ZonalKey("instance-1", "us-central1-c")}, + }, + { + "projects/some-gce-project", + &ResourceID{"some-gce-project", "projects", nil}, + }, + { + "projects/some-gce-project/regions/us-central1", + &ResourceID{"some-gce-project", "regions", meta.GlobalKey("us-central1")}, + }, + { + "projects/some-gce-project/zones/us-central1-b", + &ResourceID{"some-gce-project", "zones", meta.GlobalKey("us-central1-b")}, + }, + { + "projects/some-gce-project/global/operations/operation-1513289952196-56054460af5a0-b1dae0c3-9bbf9dbf", + &ResourceID{"some-gce-project", "operations", meta.GlobalKey("operation-1513289952196-56054460af5a0-b1dae0c3-9bbf9dbf")}, + }, + { + "projects/some-gce-project/regions/us-central1/addresses/my-address", + &ResourceID{"some-gce-project", "addresses", meta.RegionalKey("my-address", "us-central1")}, + }, + { + "projects/some-gce-project/zones/us-central1-c/instances/instance-1", + &ResourceID{"some-gce-project", "instances", meta.ZonalKey("instance-1", "us-central1-c")}, + }, + } { + r, err := ParseResourceURL(tc.in) + if err != nil { + t.Errorf("ParseResourceURL(%q) = %+v, %v; want _, nil", tc.in, r, err) + continue + } + if !r.Equal(tc.r) { + t.Errorf("ParseResourceURL(%q) = %+v, nil; want %+v, nil", tc.in, r, tc.r) + } + } + // Malformed URLs. + for _, tc := range []string{ + "", + "/", + "/a", + "/a/b", + "/a/b/c", + "/a/b/c/d", + "/a/b/c/d/e", + "/a/b/c/d/e/f", + "https://www.googleapis.com/compute/v1/projects/some-gce-project/global", + "projects/some-gce-project/global", + "projects/some-gce-project/global/foo/bar/baz", + "projects/some-gce-project/zones/us-central1-c/res", + "projects/some-gce-project/zones/us-central1-c/res/name/extra", + "https://www.googleapis.com/compute/gamma/projects/some-gce-project/global/addresses/name", + } { + r, err := ParseResourceURL(tc) + if err == nil { + t.Errorf("ParseResourceURL(%q) = %+v, %v, want _, error", tc, r, err) + } + } +} + +type A struct { + A, B, C string +} + +type B struct { + A, B, D string +} + +type E struct{} + +func (*E) MarshalJSON() ([]byte, error) { + return nil, errors.New("injected error") +} + +func TestCopyVisJSON(t *testing.T) { + t.Parallel() + + var b B + srcA := &A{"aa", "bb", "cc"} + err := copyViaJSON(&b, srcA) + if err != nil { + t.Errorf(`copyViaJSON(&b, %+v) = %v, want nil`, srcA, err) + } else { + expectedB := B{"aa", "bb", ""} + if b != expectedB { + t.Errorf("b == %+v, want %+v", b, expectedB) + } + } + + var a A + srcB := &B{"aaa", "bbb", "ccc"} + err = copyViaJSON(&a, srcB) + if err != nil { + t.Errorf(`copyViaJSON(&a, %+v) = %v, want nil`, srcB, err) + } else { + expectedA := A{"aaa", "bbb", ""} + if a != expectedA { + t.Errorf("a == %+v, want %+v", a, expectedA) + } + } + + if err := copyViaJSON(&a, &E{}); err == nil { + t.Errorf("copyViaJSON(&a, &E{}) = nil, want error") + } +} + +func TestSelfLink(t *testing.T) { + t.Parallel() + + for _, tc := range []struct{ + ver meta.Version + project string + resource string + key meta.Key + want string + }{ + { + meta.VersionAlpha, + "proj1", + "addresses", + *meta.RegionalKey("key1", "us-central1"), + "https://www.googleapis.com/compute/alpha/projects/proj1/regions/us-central1/addresses/key1", + }, + { + meta.VersionBeta, + "proj3", + "disks", + *meta.ZonalKey("key2", "us-central1-b"), + "https://www.googleapis.com/compute/beta/projects/proj3/zones/us-central1-b/disks/key2", + }, + { + meta.VersionGA, + "proj4", + "urlMaps", + *meta.GlobalKey("key3"), + "https://www.googleapis.com/compute/v1/projects/proj4/urlMaps/key3", + }, + }{ + if link := SelfLink(tc.ver, tc.project, tc.resource, tc.key); link != tc.want { + t.Errorf("SelfLink(%v, %q, %q, %v) = %v, want %q", tc.ver, tc.project, tc.resource, tc.key, link, tc.want) + } + } +} From b19149406eda9730a8f233ab374e3521fdc08016 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:34:06 -0800 Subject: [PATCH 02/18] "meta" type descriptions used for code generation --- .../providers/gce/cloud/meta/doc.go | 19 + .../providers/gce/cloud/meta/key.go | 96 +++++ .../providers/gce/cloud/meta/key_test.go | 75 ++++ .../providers/gce/cloud/meta/meta.go | 372 ++++++++++++++++++ .../providers/gce/cloud/meta/method.go | 241 ++++++++++++ .../providers/gce/cloud/meta/service.go | 273 +++++++++++++ 6 files changed, 1076 insertions(+) create mode 100644 pkg/cloudprovider/providers/gce/cloud/meta/doc.go create mode 100644 pkg/cloudprovider/providers/gce/cloud/meta/key.go create mode 100644 pkg/cloudprovider/providers/gce/cloud/meta/key_test.go create mode 100644 pkg/cloudprovider/providers/gce/cloud/meta/meta.go create mode 100644 pkg/cloudprovider/providers/gce/cloud/meta/method.go create mode 100644 pkg/cloudprovider/providers/gce/cloud/meta/service.go diff --git a/pkg/cloudprovider/providers/gce/cloud/meta/doc.go b/pkg/cloudprovider/providers/gce/cloud/meta/doc.go new file mode 100644 index 00000000000..7aa24e06379 --- /dev/null +++ b/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 diff --git a/pkg/cloudprovider/providers/gce/cloud/meta/key.go b/pkg/cloudprovider/providers/gce/cloud/meta/key.go new file mode 100644 index 00000000000..fff2543c7b0 --- /dev/null +++ b/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 +} diff --git a/pkg/cloudprovider/providers/gce/cloud/meta/key_test.go b/pkg/cloudprovider/providers/gce/cloud/meta/key_test.go new file mode 100644 index 00000000000..0f1a6df8b4c --- /dev/null +++ b/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) + } + } +} diff --git a/pkg/cloudprovider/providers/gce/cloud/meta/meta.go b/pkg/cloudprovider/providers/gce/cloud/meta/meta.go new file mode 100644 index 00000000000..3f60c00f412 --- /dev/null +++ b/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{}), + }, +} diff --git a/pkg/cloudprovider/providers/gce/cloud/meta/method.go b/pkg/cloudprovider/providers/gce/cloud/meta/method.go new file mode 100644 index 00000000000..5adf065fae4 --- /dev/null +++ b/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). 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) +} diff --git a/pkg/cloudprovider/providers/gce/cloud/meta/service.go b/pkg/cloudprovider/providers/gce/cloud/meta/service.go new file mode 100644 index 00000000000..ffa3385075b --- /dev/null +++ b/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) +} From 94ddfd17e769bc4b4b407adc864233252d62eb38 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:34:30 -0800 Subject: [PATCH 03/18] Implementation of the compute "filter" handling for List() --- .../providers/gce/cloud/filter/filter.go | 303 ++++++++++++++++++ .../providers/gce/cloud/filter/filter_test.go | 176 ++++++++++ 2 files changed, 479 insertions(+) create mode 100644 pkg/cloudprovider/providers/gce/cloud/filter/filter.go create mode 100644 pkg/cloudprovider/providers/gce/cloud/filter/filter_test.go diff --git a/pkg/cloudprovider/providers/gce/cloud/filter/filter.go b/pkg/cloudprovider/providers/gce/cloud/filter/filter.go new file mode 100644 index 00000000000..c08005726c8 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/filter/filter.go @@ -0,0 +1,303 @@ +/* +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 filter encapsulates the filter argument to compute API calls. +// +// // List all global addresses (no filter). +// c.GlobalAddresses().List(ctx, filter.None) +// +// // List global addresses filtering for name matching "abc.*". +// c.GlobalAddresses().List(ctx, filter.Regexp("name", "abc.*")) +// +// // List on multiple conditions. +// f := filter.Regexp("name", "homer.*").AndNotRegexp("name", "homers") +// c.GlobalAddresses().List(ctx, f) +package filter + +import ( + "errors" + "fmt" + "reflect" + "regexp" + "strings" + + "github.com/golang/glog" +) + +var ( + // None indicates that the List result set should not be filter (i.e. + // return all values). + None *F +) + +// Regexp returns a filter for fieldName matches regexp v. +func Regexp(fieldName, v string) *F { + return (&F{}).AndRegexp(fieldName, v) +} + +// NotRegexp returns a filter for fieldName not matches regexp v. +func NotRegexp(fieldName, v string) *F { + return (&F{}).AndNotRegexp(fieldName, v) +} + +// EqualInt returns a filter for fieldName ~ v. +func EqualInt(fieldName string, v int) *F { + return (&F{}).AndEqualInt(fieldName, v) +} + +// NotEqualInt returns a filter for fieldName != v. +func NotEqualInt(fieldName string, v int) *F { + return (&F{}).AndNotEqualInt(fieldName, v) +} + +// EqualBool returns a filter for fieldName == v. +func EqualBool(fieldName string, v bool) *F { + return (&F{}).AndEqualBool(fieldName, v) +} + +// NotEqualBool returns a filter for fieldName != v. +func NotEqualBool(fieldName string, v bool) *F { + return (&F{}).AndNotEqualBool(fieldName, v) +} + +// F is a filter to be used with List() operations. +// +// From the compute API description: +// +// Sets a filter {expression} for filtering listed resources. Your {expression} +// must be in the format: field_name comparison_string literal_string. +// +// The field_name is the name of the field you want to compare. Only atomic field +// types are supported (string, number, boolean). The comparison_string must be +// either eq (equals) or ne (not equals). The literal_string is the string value +// to filter to. The literal value must be valid for the type of field you are +// filtering by (string, number, boolean). For string fields, the literal value is +// interpreted as a regular expression using RE2 syntax. The literal value must +// match the entire field. +// +// For example, to filter for instances that do not have a name of +// example-instance, you would use name ne example-instance. +// +// You can filter on nested fields. For example, you could filter on instances +// that have set the scheduling.automaticRestart field to true. Use filtering on +// nested fields to take advantage of labels to organize and search for results +// based on label values. +// +// To filter on multiple expressions, provide each separate expression within +// parentheses. For example, (scheduling.automaticRestart eq true) +// (zone eq us-central1-f). Multiple expressions are treated as AND expressions, +// meaning that resources must match all expressions to pass the filters. +type F struct { + predicates []filterPredicate +} + +// And joins two filters together. +func (fl *F) And(rest *F) *F { + fl.predicates = append(fl.predicates, rest.predicates...) + return fl +} + +// AndRegexp adds a field match string predicate. +func (fl *F) AndRegexp(fieldName, v string) *F { + fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: equals, s: &v}) + return fl +} + +// AndNotRegexp adds a field not match string predicate. +func (fl *F) AndNotRegexp(fieldName, v string) *F { + fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: notEquals, s: &v}) + return fl +} + +// AndEqualInt adds a field == int predicate. +func (fl *F) AndEqualInt(fieldName string, v int) *F { + fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: equals, i: &v}) + return fl +} + +// AndNotEqualInt adds a field != int predicate. +func (fl *F) AndNotEqualInt(fieldName string, v int) *F { + fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: notEquals, i: &v}) + return fl +} + +// AndEqualBool adds a field == bool predicate. +func (fl *F) AndEqualBool(fieldName string, v bool) *F { + fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: equals, b: &v}) + return fl +} + +// AndNotEqualBool adds a field != bool predicate. +func (fl *F) AndNotEqualBool(fieldName string, v bool) *F { + fl.predicates = append(fl.predicates, filterPredicate{fieldName: fieldName, op: notEquals, b: &v}) + return fl +} + +func (fl *F) String() string { + if len(fl.predicates) == 1 { + return fl.predicates[0].String() + } + + var pl []string + for _, p := range fl.predicates { + pl = append(pl, "("+p.String()+")") + } + return strings.Join(pl, " ") +} + +// Match returns true if the F as specifies matches the given object. This +// is used by the Mock implementations to perform filtering and SHOULD NOT be +// used in production code as it is not well-tested to be equivalent to the +// actual compute API. +func (fl *F) Match(obj interface{}) bool { + if fl == nil { + return true + } + for _, p := range fl.predicates { + if !p.match(obj) { + return false + } + } + return true +} + +type filterOp int + +const ( + equals filterOp = iota + notEquals filterOp = iota +) + +// filterPredicate is an individual predicate for a fieldName and value. +type filterPredicate struct { + fieldName string + + op filterOp + s *string + i *int + b *bool +} + +func (fp *filterPredicate) String() string { + var op string + switch fp.op { + case equals: + op = "eq" + case notEquals: + op = "ne" + default: + op = "invalidOp" + } + + var value string + switch { + case fp.s != nil: + // There does not seem to be any sort of escaping as specified in the + // document. This means it's possible to create malformed expressions. + value = *fp.s + case fp.i != nil: + value = fmt.Sprintf("%d", *fp.i) + case fp.b != nil: + value = fmt.Sprintf("%t", *fp.b) + default: + value = "invalidValue" + } + + return fmt.Sprintf("%s %s %s", fp.fieldName, op, value) +} + +func (fp *filterPredicate) match(o interface{}) bool { + v, err := extractValue(fp.fieldName, o) + glog.V(6).Infof("extractValue(%q, %#v) = %v, %v", fp.fieldName, o, v, err) + if err != nil { + return false + } + + var match bool + switch x := v.(type) { + case string: + if fp.s == nil { + return false + } + re, err := regexp.Compile(*fp.s) + if err != nil { + glog.Errorf("Match regexp %q is invalid: %v", *fp.s, err) + return false + } + match = re.Match([]byte(x)) + case int: + if fp.i == nil { + return false + } + match = x == *fp.i + case bool: + if fp.b == nil { + return false + } + match = x == *fp.b + } + + switch fp.op { + case equals: + return match + case notEquals: + return !match + } + + return false +} + +// snakeToCamelCase converts from "names_like_this" to "NamesLikeThis" to +// interoperate between proto and Golang naming conventions. +func snakeToCamelCase(s string) string { + parts := strings.Split(s, "_") + var ret string + for _, x := range parts { + ret += strings.Title(x) + } + return ret +} + +// extractValue returns the value of the field named by path in object o if it exists. +func extractValue(path string, o interface{}) (interface{}, error) { + parts := strings.Split(path, ".") + for _, f := range parts { + v := reflect.ValueOf(o) + // Dereference Ptr to handle *struct. + if v.Kind() == reflect.Ptr { + if v.IsNil() { + return nil, errors.New("field is nil") + } + v = v.Elem() + } + if v.Kind() != reflect.Struct { + return nil, fmt.Errorf("cannot get field from non-struct (%T)", o) + } + v = v.FieldByName(snakeToCamelCase(f)) + if !v.IsValid() { + return nil, fmt.Errorf("cannot get field %q as it is not a valid field in %T", f, o) + } + if !v.CanInterface() { + return nil, fmt.Errorf("cannot get field %q in obj of type %T", f, o) + } + o = v.Interface() + } + switch o.(type) { + case string, int, bool: + return o, nil + } + return nil, fmt.Errorf("unhandled object of type %T", o) +} diff --git a/pkg/cloudprovider/providers/gce/cloud/filter/filter_test.go b/pkg/cloudprovider/providers/gce/cloud/filter/filter_test.go new file mode 100644 index 00000000000..46b3c279a47 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/filter/filter_test.go @@ -0,0 +1,176 @@ +/* +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 filter + +import ( + "reflect" + "testing" +) + +func TestFilterToString(t *testing.T) { + t.Parallel() + + for _, tc := range []struct { + f *F + want string + }{ + {Regexp("field1", "abc"), `field1 eq abc`}, + {NotRegexp("field1", "abc"), `field1 ne abc`}, + {EqualInt("field1", 13), "field1 eq 13"}, + {NotEqualInt("field1", 13), "field1 ne 13"}, + {EqualBool("field1", true), "field1 eq true"}, + {NotEqualBool("field1", true), "field1 ne true"}, + {Regexp("field1", "abc").AndRegexp("field2", "def"), `(field1 eq abc) (field2 eq def)`}, + {Regexp("field1", "abc").AndNotEqualInt("field2", 17), `(field1 eq abc) (field2 ne 17)`}, + {Regexp("field1", "abc").And(EqualInt("field2", 17)), `(field1 eq abc) (field2 eq 17)`}, + } { + if tc.f.String() != tc.want { + t.Errorf("filter %#v String() = %q, want %q", tc.f, tc.f.String(), tc.want) + } + } +} + +func TestFilterMatch(t *testing.T) { + t.Parallel() + + type inner struct { + X string + } + type S struct { + S string + I int + B bool + Unhandled struct{} + NestedField *inner + } + + for _, tc := range []struct { + f *F + o interface{} + want bool + }{ + {f: None, o: &S{}, want: true}, + {f: Regexp("s", "abc"), o: &S{}}, + {f: EqualInt("i", 10), o: &S{}}, + {f: EqualBool("b", true), o: &S{}}, + {f: NotRegexp("s", "abc"), o: &S{}, want: true}, + {f: NotEqualInt("i", 10), o: &S{}, want: true}, + {f: NotEqualBool("b", true), o: &S{}, want: true}, + {f: Regexp("s", "abc").AndEqualBool("b", true), o: &S{}}, + {f: Regexp("s", "abc"), o: &S{S: "abc"}, want: true}, + {f: Regexp("s", "a.*"), o: &S{S: "abc"}, want: true}, + {f: Regexp("s", "a((("), o: &S{S: "abc"}}, + {f: NotRegexp("s", "abc"), o: &S{S: "abc"}}, + {f: EqualInt("i", 10), o: &S{I: 11}}, + {f: EqualInt("i", 10), o: &S{I: 10}, want: true}, + {f: Regexp("s", "abc").AndEqualBool("b", true), o: &S{S: "abc"}}, + {f: Regexp("s", "abcd").AndEqualBool("b", true), o: &S{S: "abc"}}, + {f: Regexp("s", "abc").AndEqualBool("b", true), o: &S{S: "abc", B: true}, want: true}, + {f: Regexp("s", "abc").And(EqualBool("b", true)), o: &S{S: "abc", B: true}, want: true}, + {f: Regexp("unhandled", "xyz"), o: &S{}}, + {f: Regexp("nested_field.x", "xyz"), o: &S{}}, + {f: Regexp("nested_field.x", "xyz"), o: &S{NestedField: &inner{"xyz"}}, want: true}, + {f: NotRegexp("nested_field.x", "xyz"), o: &S{NestedField: &inner{"xyz"}}}, + {f: Regexp("nested_field.y", "xyz"), o: &S{NestedField: &inner{"xyz"}}}, + {f: Regexp("nested_field", "xyz"), o: &S{NestedField: &inner{"xyz"}}}, + } { + got := tc.f.Match(tc.o) + if got != tc.want { + t.Errorf("%v: Match(%+v) = %v, want %v", tc.f, tc.o, got, tc.want) + } + } +} + +func TestFilterSnakeToCamelCase(t *testing.T) { + t.Parallel() + + for _, tc := range []struct { + s string + want string + }{ + {"", ""}, + {"abc", "Abc"}, + {"_foo", "Foo"}, + {"a_b_c", "ABC"}, + {"a_BC_def", "ABCDef"}, + {"a_Bc_def", "ABcDef"}, + } { + got := snakeToCamelCase(tc.s) + if got != tc.want { + t.Errorf("snakeToCamelCase(%q) = %q, want %q", tc.s, got, tc.want) + } + } +} + +func TestFilterExtractValue(t *testing.T) { + t.Parallel() + + type nest2 struct { + Y string + } + type nest struct { + X string + Nest2 nest2 + } + st := &struct { + S string + I int + F bool + Nest nest + NestPtr *nest + + Unhandled float64 + }{ + "abc", + 13, + true, + nest{"xyz", nest2{"zzz"}}, + &nest{"yyy", nest2{}}, + 0.0, + } + + for _, tc := range []struct { + path string + o interface{} + want interface{} + wantErr bool + }{ + {path: "s", o: st, want: "abc"}, + {path: "i", o: st, want: 13}, + {path: "f", o: st, want: true}, + {path: "nest.x", o: st, want: "xyz"}, + {path: "nest_ptr.x", o: st, want: "yyy"}, + // Error cases. + {path: "", o: st, wantErr: true}, + {path: "no_such_field", o: st, wantErr: true}, + {path: "s.invalid_type", o: st, wantErr: true}, + {path: "unhandled", o: st, wantErr: true}, + {path: "nest.x", o: &struct{ Nest *nest }{}, wantErr: true}, + } { + o, err := extractValue(tc.path, tc.o) + gotErr := err != nil + if gotErr != tc.wantErr { + t.Errorf("extractValue(%v, %+v) = %v, %v; gotErr = %v, tc.wantErr = %v", tc.path, tc.o, o, err, gotErr, tc.wantErr) + } + if err != nil { + continue + } + if !reflect.DeepEqual(o, tc.want) { + t.Errorf("extractValue(%v, %+v) = %v, nil; want %v, nil", tc.path, tc.o, o, tc.want) + } + } +} From 8250950d15521f9ffa1f966a5b358bda65197f49 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:34:37 -0800 Subject: [PATCH 04/18] documentation --- pkg/cloudprovider/providers/gce/cloud/doc.go | 111 +++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 pkg/cloudprovider/providers/gce/cloud/doc.go diff --git a/pkg/cloudprovider/providers/gce/cloud/doc.go b/pkg/cloudprovider/providers/gce/cloud/doc.go new file mode 100644 index 00000000000..d0d7a6cfb19 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/doc.go @@ -0,0 +1,111 @@ +/* +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 cloud implements a more golang friendly interface to the GCE compute +// API. The code in this package is generated automatically via the generator +// implemented in "gen/main.go". The code generator creates the basic CRUD +// actions for the given resource: "Insert", "Get", "List" and "Delete". +// Additional methods by customizing the ServiceInfo object (see below). +// Generated code includes a full mock of the GCE compute API. +// +// Usage +// +// The root of the GCE compute API is the interface "Cloud". Code written using +// Cloud can be used against the actual implementation "GCE" or "MockGCE". +// +// func foo(cloud Cloud) { +// igs, err := cloud.InstanceGroups().List(ctx, "us-central1-b", filter.None) +// ... +// } +// // Run foo against the actual cloud. +// foo(NewGCE(&Service{...})) +// // Run foo with a mock. +// foo(NewMockGCE()) +// +// Rate limiting and routing +// +// The generated code allows for custom policies for operation rate limiting +// and GCE project routing. See RateLimiter and ProjectRouter for more details. +// +// Mocks +// +// Mocks are automatically generated for each type implementing basic logic for +// resource manipulation. This eliminates the boilerplate required to mock GCE +// functionality. Each method will also have a corresponding "xxxHook" +// function generated in the mock structure where unit test code can hook the +// execution of the method. +// +// Mocks for different versions of the same service will share the same set of +// objects, i.e. an alpha object will be visible with beta and GA methods. +// Note that translation is done with JSON serialization between the API versions. +// +// Changing service code generation +// +// The list of services to generate is contained in "meta/meta.go". To add a +// service, add an entry to the list "meta.AllServices". An example entry: +// +// &ServiceInfo{ +// Object: "InstanceGroup", // Name of the object type. +// Service: "InstanceGroups", // Name of the service. +// version: meta.VersionAlpha, // API version (one entry per version is needed). +// keyType: Zonal, // What kind of resource this is. +// serviceType: reflect.TypeOf(&alpha.InstanceGroupsService{}), // Associated golang type. +// additionalMethods: []string{ // Additional methods to generate code for. +// "SetNamedPorts", +// }, +// options: // Or'd ("|") together. +// } +// +// Read-only objects +// +// Services such as Regions and Zones do not allow for mutations. Specify +// "ReadOnly" in ServiceInfo.options to omit the mutation methods. +// +// Adding custom methods +// +// Some methods that may not be properly handled by the generated code. To enable +// addition of custom code to the generated mocks, set the "CustomOps" option +// in "meta.ServiceInfo" entry. This will make the generated service interface +// embed a "Ops" interface. This interface MUST be written by hand +// and contain the custom method logic. Corresponding methods must be added to +// the corresponding Mockxxx and GCExxx struct types. +// +// // In "meta/meta.go": +// &ServiceInfo{ +// Object: "InstanceGroup", +// ... +// options: CustomOps, +// } +// +// // In the generated code "gen.go": +// type InstanceGroups interface { +// InstanceGroupsOps // Added by CustomOps option. +// ... +// } +// +// // In hand written file: +// type InstanceGroupsOps interface { +// MyMethod() +// } +// +// func (mock *MockInstanceGroups) MyMethod() { +// // Custom mock implementation. +// } +// +// func (gce *GCEInstanceGroups) MyMethod() { +// // Custom implementation. +// } +package cloud From 75bff35884a52275825741c3cbf1da46ca363d5f Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:34:58 -0800 Subject: [PATCH 05/18] long running operation support --- pkg/cloudprovider/providers/gce/cloud/op.go | 142 ++++++++++++++++++++ 1 file changed, 142 insertions(+) create mode 100644 pkg/cloudprovider/providers/gce/cloud/op.go diff --git a/pkg/cloudprovider/providers/gce/cloud/op.go b/pkg/cloudprovider/providers/gce/cloud/op.go new file mode 100644 index 00000000000..92ee6f3f6f3 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/op.go @@ -0,0 +1,142 @@ +/* +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 cloud + +import ( + "context" + + alpha "google.golang.org/api/compute/v0.alpha" + beta "google.golang.org/api/compute/v0.beta" + ga "google.golang.org/api/compute/v1" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" +) + +// operation is a GCE operation that can be watied on. +type operation interface { + // isDone queries GCE for the done status. This call can block. + isDone(ctx context.Context) (bool, error) + // rateLimitKey returns the rate limit key to use for the given operation. + // This rate limit will govern how fast the server will be polled for + // operation completion status. + rateLimitKey() *RateLimitKey +} + +type gaOperation struct { + s *Service + op *ga.Operation + projectID string +} + +func (o *gaOperation) isDone(ctx context.Context) (bool, error) { + var ( + op *ga.Operation + err error + ) + + switch { + case o.op.Region != "": + op, err = o.s.GA.RegionOperations.Get(o.projectID, o.op.Region, o.op.Name).Context(ctx).Do() + case o.op.Zone != "": + op, err = o.s.GA.ZoneOperations.Get(o.projectID, o.op.Zone, o.op.Name).Context(ctx).Do() + default: + op, err = o.s.GA.GlobalOperations.Get(o.projectID, o.op.Name).Context(ctx).Do() + } + if err != nil { + return false, err + } + return op != nil && op.Status == "DONE", nil +} + +func (o *gaOperation) rateLimitKey() *RateLimitKey { + return &RateLimitKey{ + ProjectID: o.projectID, + Operation: "Get", + Service: "Operations", + Version: meta.VersionGA, + } +} + +type alphaOperation struct { + s *Service + op *alpha.Operation + projectID string +} + +func (o *alphaOperation) isDone(ctx context.Context) (bool, error) { + var ( + op *alpha.Operation + err error + ) + + switch { + case o.op.Region != "": + op, err = o.s.Alpha.RegionOperations.Get(o.projectID, o.op.Region, o.op.Name).Context(ctx).Do() + case o.op.Zone != "": + op, err = o.s.Alpha.ZoneOperations.Get(o.projectID, o.op.Zone, o.op.Name).Context(ctx).Do() + default: + op, err = o.s.Alpha.GlobalOperations.Get(o.projectID, o.op.Name).Context(ctx).Do() + } + if err != nil { + return false, err + } + return op != nil && op.Status == "DONE", nil +} + +func (o *alphaOperation) rateLimitKey() *RateLimitKey { + return &RateLimitKey{ + ProjectID: o.projectID, + Operation: "Get", + Service: "Operations", + Version: meta.VersionAlpha, + } +} + +type betaOperation struct { + s *Service + op *beta.Operation + projectID string +} + +func (o *betaOperation) isDone(ctx context.Context) (bool, error) { + var ( + op *beta.Operation + err error + ) + + switch { + case o.op.Region != "": + op, err = o.s.Beta.RegionOperations.Get(o.projectID, o.op.Region, o.op.Name).Context(ctx).Do() + case o.op.Zone != "": + op, err = o.s.Beta.ZoneOperations.Get(o.projectID, o.op.Zone, o.op.Name).Context(ctx).Do() + default: + op, err = o.s.Beta.GlobalOperations.Get(o.projectID, o.op.Name).Context(ctx).Do() + } + if err != nil { + return false, err + } + return op != nil && op.Status == "DONE", nil +} + +func (o *betaOperation) rateLimitKey() *RateLimitKey { + return &RateLimitKey{ + ProjectID: o.projectID, + Operation: "Get", + Service: "Operations", + Version: meta.VersionBeta, + } +} From 968cce929c500cd8d5e172a9e1e70924e7b427e0 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:35:09 -0800 Subject: [PATCH 06/18] code generation --- .../providers/gce/cloud/gen/main.go | 1140 +++++++++++++++++ 1 file changed, 1140 insertions(+) create mode 100644 pkg/cloudprovider/providers/gce/cloud/gen/main.go diff --git a/pkg/cloudprovider/providers/gce/cloud/gen/main.go b/pkg/cloudprovider/providers/gce/cloud/gen/main.go new file mode 100644 index 00000000000..f8dcd730b9f --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/gen/main.go @@ -0,0 +1,1140 @@ +/* +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. +*/ + +// Generator for GCE compute wrapper code. You must regenerate the code after +// modifying this file: +// +// $ go run gen/main.go > gen.go +package main + +import ( + "bytes" + "flag" + "fmt" + "io" + "os" + "os/exec" + "text/template" + "time" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" + "github.com/golang/glog" +) + +const ( + gofmt = "gofmt" + packageRoot = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud" + + // readOnly specifies that the given resource is read-only and should not + // have insert() or delete() methods generated for the wrapper. + readOnly = iota +) + +var flags = struct { + gofmt bool + mode string +}{} + +func init() { + flag.BoolVar(&flags.gofmt, "gofmt", true, "run output through gofmt") + flag.StringVar(&flags.mode, "mode", "src", "content to generate: src, test, dummy") +} + +// gofmtContent runs "gofmt" on the given contents. +func gofmtContent(r io.Reader) string { + cmd := exec.Command(gofmt, "-s") + out := &bytes.Buffer{} + cmd.Stdin = r + cmd.Stdout = out + cmdErr := &bytes.Buffer{} + cmd.Stderr = cmdErr + + if err := cmd.Run(); err != nil { + fmt.Fprintf(os.Stderr, cmdErr.String()) + panic(err) + } + return out.String() +} + +// genHeader generate the header for the file. +func genHeader(wr io.Writer) { + const text = `/* +Copyright {{.Year}} 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. +*/ + +// This file was generated by "go run gen/main.go > gen.go". Do not edit +// directly. + +package cloud + +import ( + "context" + "fmt" + "net/http" + "sync" + + "google.golang.org/api/googleapi" + "github.com/golang/glog" + + "{{.PackageRoot}}/filter" + "{{.PackageRoot}}/meta" + +` + tmpl := template.Must(template.New("header").Parse(text)) + values := map[string]string{ + "Year": fmt.Sprintf("%v", time.Now().Year()), + "PackageRoot": packageRoot, + } + if err := tmpl.Execute(wr, values); err != nil { + panic(err) + } + + var hasGA, hasAlpha, hasBeta bool + for _, s := range meta.AllServices { + switch s.Version() { + case meta.VersionGA: + hasGA = true + case meta.VersionAlpha: + hasAlpha = true + case meta.VersionBeta: + hasBeta = true + } + } + if hasAlpha { + fmt.Fprintln(wr, ` alpha "google.golang.org/api/compute/v0.alpha"`) + } + if hasBeta { + fmt.Fprintln(wr, ` beta "google.golang.org/api/compute/v0.beta"`) + } + if hasGA { + fmt.Fprintln(wr, ` ga "google.golang.org/api/compute/v1"`) + } + fmt.Fprintf(wr, ")\n\n") +} + +// genStubs generates the interface and wrapper stubs. +func genStubs(wr io.Writer) { + const text = `// Cloud is an interface for the GCE compute API. +type Cloud interface { +{{- range .All}} + {{.WrapType}}() {{.WrapType}} +{{- end}} +} + +// NewGCE returns a GCE. +func NewGCE(s *Service) *GCE { + g := &GCE{ + {{- range .All}} + {{.Field}}: &{{.GCEWrapType}}{s}, + {{- end}} + } + return g +} + +// GCE implements Cloud. +var _ Cloud = (*GCE)(nil) + +// GCE is the golang adapter for the compute APIs. +type GCE struct { +{{- range .All}} + {{.Field}} *{{.GCEWrapType}} +{{- end}} +} + +{{range .All}} +func (gce *GCE) {{.WrapType}}() {{.WrapType}} { + return gce.{{.Field}} +} +{{- end}} + +// NewMockGCE returns a new mock for GCE. +func NewMockGCE() *MockGCE { + {{- range .Groups}} + mock{{.Service}}Objs := map[meta.Key]*Mock{{.Service}}Obj{} + {{- end}} + + mock := &MockGCE{ + {{- range .All}} + {{.MockField}}: New{{.MockWrapType}}(mock{{.Service}}Objs), + {{- end}} + } + return mock +} + +// MockGCE implements Cloud. +var _ Cloud = (*MockGCE)(nil) + +// MockGCE is the mock for the compute API. +type MockGCE struct { +{{- range .All}} + {{.MockField}} *{{.MockWrapType}} +{{- end}} +} +{{range .All}} +func (mock *MockGCE) {{.WrapType}}() {{.WrapType}} { + return mock.{{.MockField}} +} +{{end}} + +{{range .Groups}} +// Mock{{.Service}}Obj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type Mock{{.Service}}Obj struct { + Obj interface{} +} +{{- if .HasAlpha}} +// ToAlpha retrieves the given version of the object. +func (m *Mock{{.Service}}Obj) ToAlpha() *{{.Alpha.FQObjectType}} { + if ret, ok := m.Obj.(*{{.Alpha.FQObjectType}}); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &{{.Alpha.FQObjectType}}{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *{{.Alpha.FQObjectType}} via JSON: %v", m.Obj, err) + } + return ret +} +{{- end}} +{{- if .HasBeta}} +// ToBeta retrieves the given version of the object. +func (m *Mock{{.Service}}Obj) ToBeta() *{{.Beta.FQObjectType}} { + if ret, ok := m.Obj.(*{{.Beta.FQObjectType}}); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &{{.Beta.FQObjectType}}{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *{{.Beta.FQObjectType}} via JSON: %v", m.Obj, err) + } + return ret +} +{{- end}} +{{- if .HasGA}} +// ToGA retrieves the given version of the object. +func (m *Mock{{.Service}}Obj) ToGA() *{{.GA.FQObjectType}} { + if ret, ok := m.Obj.(*{{.GA.FQObjectType}}); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &{{.GA.FQObjectType}}{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *{{.GA.FQObjectType}} via JSON: %v", m.Obj, err) + } + return ret +} +{{- end}} +{{- end}} +` + data := struct { + All []*meta.ServiceInfo + Groups map[string]*meta.ServiceGroup + }{meta.AllServices, meta.AllServicesByGroup} + + tmpl := template.Must(template.New("interface").Parse(text)) + if err := tmpl.Execute(wr, data); err != nil { + panic(err) + } +} + +// genTypes generates the type wrappers. +func genTypes(wr io.Writer) { + const text = `// {{.WrapType}} is an interface that allows for mocking of {{.Service}}. +type {{.WrapType}} interface { +{{- if .GenerateCustomOps}} + // {{.WrapTypeOps}} is an interface with additional non-CRUD type methods. + // This interface is expected to be implemented by hand (non-autogenerated). + {{.WrapTypeOps}} +{{- end}} +{{- if .GenerateGet}} + Get(ctx context.Context, key meta.Key) (*{{.FQObjectType}}, error) +{{- end -}} +{{- if .GenerateList}} +{{- if .KeyIsGlobal}} + List(ctx context.Context, fl *filter.F) ([]*{{.FQObjectType}}, error) +{{- end -}} +{{- if .KeyIsRegional}} + List(ctx context.Context, region string, fl *filter.F) ([]*{{.FQObjectType}}, error) +{{- end -}} +{{- if .KeyIsZonal}} + List(ctx context.Context, zone string, fl *filter.F) ([]*{{.FQObjectType}}, error) +{{- end -}} +{{- end -}} +{{- if .GenerateInsert}} + Insert(ctx context.Context, key meta.Key, obj *{{.FQObjectType}}) error +{{- end -}} +{{- if .GenerateDelete}} + Delete(ctx context.Context, key meta.Key) error +{{- end -}} +{{- if .AggregatedList}} + AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*{{.FQObjectType}}, error) +{{- end}} +{{- with .Methods -}} +{{- range .}} + {{.InterfaceFunc}} +{{- end -}} +{{- end}} +} + +// New{{.MockWrapType}} returns a new mock for {{.Service}}. +func New{{.MockWrapType}}(objs map[meta.Key]*Mock{{.Service}}Obj) *{{.MockWrapType}} { + mock := &{{.MockWrapType}}{ + Objects: objs, + {{- if .GenerateGet}} + GetError: map[meta.Key]error{}, + {{- end -}} + {{- if .GenerateInsert}} + InsertError: map[meta.Key]error{}, + {{- end -}} + {{- if .GenerateDelete}} + DeleteError: map[meta.Key]error{}, + {{- end}} + } + return mock +} + +// {{.MockWrapType}} is the mock for {{.Service}}. +type {{.MockWrapType}} struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*Mock{{.Service}}Obj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + {{- if .GenerateGet}} + GetError map[meta.Key]error + {{- end -}} + {{- if .GenerateList}} + ListError *error + {{- end -}} + {{- if .GenerateInsert}} + InsertError map[meta.Key]error + {{- end -}} + {{- if .GenerateDelete}} + DeleteError map[meta.Key]error + {{- end -}} + {{- if .AggregatedList}} + AggregatedListError *error + {{- end}} + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + {{- if .GenerateGet}} + GetHook func(m *{{.MockWrapType}}, ctx context.Context, key meta.Key) (bool, *{{.FQObjectType}}, error) + {{- end -}} + {{- if .GenerateList}} + {{- if .KeyIsGlobal}} + ListHook func(m *{{.MockWrapType}}, ctx context.Context, fl *filter.F) (bool, []*{{.FQObjectType}}, error) + {{- end -}} + {{- if .KeyIsRegional}} + ListHook func(m *{{.MockWrapType}}, ctx context.Context, region string, fl *filter.F) (bool, []*{{.FQObjectType}}, error) + {{- end -}} + {{- if .KeyIsZonal}} + ListHook func(m *{{.MockWrapType}}, ctx context.Context, zone string, fl *filter.F) (bool, []*{{.FQObjectType}}, error) + {{- end}} + {{- end -}} + {{- if .GenerateInsert}} + InsertHook func(m *{{.MockWrapType}}, ctx context.Context, key meta.Key, obj *{{.FQObjectType}}) (bool, error) + {{- end -}} + {{- if .GenerateDelete}} + DeleteHook func(m *{{.MockWrapType}}, ctx context.Context, key meta.Key) (bool, error) + {{- end -}} + {{- if .AggregatedList}} + AggregatedListHook func(m *{{.MockWrapType}}, ctx context.Context, fl *filter.F) (bool, map[string][]*{{.FQObjectType}}, error) + {{- end}} + +{{- with .Methods -}} +{{- range .}} + {{.MockHook}} +{{- end -}} +{{- end}} + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +{{- if .GenerateGet}} +// Get returns the object from the mock. +func (m *{{.MockWrapType}}) Get(ctx context.Context, key meta.Key) (*{{.FQObjectType}}, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("{{.MockWrapType}}.Get(%v, %s) = %+v, %v", ctx, key, obj ,err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("{{.MockWrapType}}.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.To{{.VersionTitle}}() + glog.V(5).Infof("{{.MockWrapType}}.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("{{.MockWrapType}} %v not found", key), + } + glog.V(5).Infof("{{.MockWrapType}}.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} +{{- end}} + +{{- if .GenerateList}} +{{if .KeyIsGlobal -}} +// List all of the objects in the mock. +func (m *{{.MockWrapType}}) List(ctx context.Context, fl *filter.F) ([]*{{.FQObjectType}}, error) { +{{- end -}} +{{- if .KeyIsRegional -}} +// List all of the objects in the mock in the given region. +func (m *{{.MockWrapType}}) List(ctx context.Context, region string, fl *filter.F) ([]*{{.FQObjectType}}, error) { +{{- end -}} +{{- if .KeyIsZonal -}} +// List all of the objects in the mock in the given zone. +func (m *{{.MockWrapType}}) List(ctx context.Context, zone string, fl *filter.F) ([]*{{.FQObjectType}}, error) { +{{- end}} + if m.ListHook != nil { + {{if .KeyIsGlobal -}} + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("{{.MockWrapType}}.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + {{- end -}} + {{- if .KeyIsRegional -}} + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("{{.MockWrapType}}.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + {{- end -}} + {{- if .KeyIsZonal -}} + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("{{.MockWrapType}}.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + {{- end}} + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + {{if .KeyIsGlobal -}} + glog.V(5).Infof("{{.MockWrapType}}.List(%v, %v) = nil, %v", ctx, fl, err) + {{- end -}} + {{- if .KeyIsRegional -}} + glog.V(5).Infof("{{.MockWrapType}}.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + {{- end -}} + {{- if .KeyIsZonal -}} + glog.V(5).Infof("{{.MockWrapType}}.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + {{- end}} + + return nil, *m.ListError + } + + var objs []*{{.FQObjectType}} +{{- if .KeyIsGlobal}} + for _, obj := range m.Objects { +{{- else}} + for key, obj := range m.Objects { +{{- end -}} +{{- if .KeyIsRegional}} + if key.Region != region { + continue + } +{{- end -}} +{{- if .KeyIsZonal}} + if key.Zone != zone { + continue + } +{{- end}} + if ! fl.Match(obj.To{{.VersionTitle}}()) { + continue + } + objs = append(objs, obj.To{{.VersionTitle}}()) + } + + {{if .KeyIsGlobal -}} + glog.V(5).Infof("{{.MockWrapType}}.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + {{- end -}} + {{- if .KeyIsRegional -}} + glog.V(5).Infof("{{.MockWrapType}}.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + {{- end -}} + {{- if .KeyIsZonal -}} + glog.V(5).Infof("{{.MockWrapType}}.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + {{- end}} + return objs, nil +} +{{- end}} + +{{- if .GenerateInsert}} +// Insert is a mock for inserting/creating a new object. +func (m *{{.MockWrapType}}) Insert(ctx context.Context, key meta.Key, obj *{{.FQObjectType}}) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("{{.MockWrapType}}.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("{{.MockWrapType}}.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("{{.MockWrapType}} %v exists", key), + } + glog.V(5).Infof("{{.MockWrapType}}.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.Version{{.VersionTitle}}, "mock-project", "{{.Resource}}", key) + } + + m.Objects[key] = &Mock{{.Service}}Obj{obj} + glog.V(5).Infof("{{.MockWrapType}}.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} +{{- end}} + +{{- if .GenerateDelete}} +// Delete is a mock for deleting the object. +func (m *{{.MockWrapType}}) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("{{.MockWrapType}}.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("{{.MockWrapType}}.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("{{.MockWrapType}} %v not found", key), + } + glog.V(5).Infof("{{.MockWrapType}}.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("{{.MockWrapType}}.Delete(%v, %v) = nil", ctx, key) + return nil +} +{{- end}} + +{{- if .AggregatedList}} +// AggregatedList is a mock for AggregatedList. +func (m *{{.MockWrapType}}) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*{{.FQObjectType}}, error) { + if m.AggregatedListHook != nil { + if intercept, objs, err := m.AggregatedListHook(m, ctx, fl); intercept { + glog.V(5).Infof("{{.MockWrapType}}.AggregatedList(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.AggregatedListError != nil { + err := *m.AggregatedListError + glog.V(5).Infof("{{.MockWrapType}}.AggregatedList(%v, %v) = nil, %v", ctx, fl, err) + return nil, err + } + + objs := map[string][]*{{.FQObjectType}}{} + for _, obj := range m.Objects { + res, err := ParseResourceURL(obj.To{{.VersionTitle}}().SelfLink) + {{- if .KeyIsRegional}} + location := res.Key.Region + {{- end -}} + {{- if .KeyIsZonal}} + location := res.Key.Zone + {{- end}} + if err != nil { + glog.V(5).Infof("{{.MockWrapType}}.AggregatedList(%v, %v) = nil, %v", ctx, fl, err) + return nil, err + } + if ! fl.Match(obj.To{{.VersionTitle}}()) { + continue + } + objs[location] = append(objs[location], obj.To{{.VersionTitle}}()) + } + glog.V(5).Infof("{{.MockWrapType}}.AggregatedList(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} +{{- end}} + +// Obj wraps the object for use in the mock. +func (m *{{.MockWrapType}}) Obj(o *{{.FQObjectType}}) *Mock{{.Service}}Obj { + return &Mock{{.Service}}Obj{o} +} + +{{with .Methods -}} +{{- range .}} +// {{.Name}} is a mock for the corresponding method. +func (m *{{.MockWrapType}}) {{.FcnArgs}} { +{{- if eq .ReturnType "Operation"}} + if m.{{.MockHookName}} != nil { + return m.{{.MockHookName}}(m, ctx, key {{.CallArgs}}) + } + return nil +{{- else}} + if m.{{.MockHookName}} != nil { + return m.{{.MockHookName}}(m, ctx, key {{.CallArgs}}) + } + return nil, fmt.Errorf("{{.MockHookName}} must be set") +{{- end}} +} +{{end -}} +{{- end}} +// {{.GCEWrapType}} is a simplifying adapter for the GCE {{.Service}}. +type {{.GCEWrapType}} struct { + s *Service +} + +{{- if .GenerateGet}} +// Get the {{.Object}} named by key. +func (g *{{.GCEWrapType}}) Get(ctx context.Context, key meta.Key) (*{{.FQObjectType}}, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "{{.Version}}", "{{.Service}}") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("{{.Version}}"), + Service: "{{.Service}}", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } +{{- if .KeyIsGlobal}} + call := g.s.{{.VersionTitle}}.{{.Service}}.Get(projectID, key.Name) +{{- end -}} +{{- if .KeyIsRegional}} + call := g.s.{{.VersionTitle}}.{{.Service}}.Get(projectID, key.Region, key.Name) +{{- end -}} +{{- if .KeyIsZonal}} + call := g.s.{{.VersionTitle}}.{{.Service}}.Get(projectID, key.Zone, key.Name) +{{- end}} + call.Context(ctx) + return call.Do() +} +{{- end}} + +{{- if .GenerateList}} +// List all {{.Object}} objects. +{{- if .KeyIsGlobal}} +func (g *{{.GCEWrapType}}) List(ctx context.Context, fl *filter.F) ([]*{{.FQObjectType}}, error) { +{{- end -}} +{{- if .KeyIsRegional}} +func (g *{{.GCEWrapType}}) List(ctx context.Context, region string, fl *filter.F) ([]*{{.FQObjectType}}, error) { +{{- end -}} +{{- if .KeyIsZonal}} +func (g *{{.GCEWrapType}}) List(ctx context.Context, zone string, fl *filter.F) ([]*{{.FQObjectType}}, error) { +{{- end}} +projectID := g.s.ProjectRouter.ProjectID(ctx, "{{.Version}}", "{{.Service}}") +rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("{{.Version}}"), + Service: "{{.Service}}", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } +{{- if .KeyIsGlobal}} + call := g.s.{{.VersionTitle}}.{{.Service}}.List(projectID) +{{- end -}} +{{- if .KeyIsRegional}} + call := g.s.{{.VersionTitle}}.{{.Service}}.List(projectID, region) +{{- end -}} +{{- if .KeyIsZonal}} + call := g.s.{{.VersionTitle}}.{{.Service}}.List(projectID, zone) +{{- end}} + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*{{.FQObjectType}} + f := func(l *{{.ObjectListType}}) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} +{{- end}} + +{{- if .GenerateInsert}} +// Insert {{.Object}} with key of value obj. +func (g *{{.GCEWrapType}}) Insert(ctx context.Context, key meta.Key, obj *{{.FQObjectType}}) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "{{.Version}}", "{{.Service}}") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("{{.Version}}"), + Service: "{{.Service}}", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name +{{- if .KeyIsGlobal}} + call := g.s.{{.VersionTitle}}.{{.Service}}.Insert(projectID, obj) +{{- end -}} +{{- if .KeyIsRegional}} + call := g.s.{{.VersionTitle}}.{{.Service}}.Insert(projectID, key.Region, obj) +{{- end -}} +{{- if .KeyIsZonal}} + call := g.s.{{.VersionTitle}}.{{.Service}}.Insert(projectID, key.Zone, obj) +{{- end}} + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} +{{- end}} + +{{- if .GenerateDelete}} +// Delete the {{.Object}} referenced by key. +func (g *{{.GCEWrapType}}) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "{{.Version}}", "{{.Service}}") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("{{.Version}}"), + Service: "{{.Service}}", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } +{{- if .KeyIsGlobal}} + call := g.s.{{.VersionTitle}}.{{.Service}}.Delete(projectID, key.Name) +{{end -}} +{{- if .KeyIsRegional}} + call := g.s.{{.VersionTitle}}.{{.Service}}.Delete(projectID, key.Region, key.Name) +{{- end -}} +{{- if .KeyIsZonal}} + call := g.s.{{.VersionTitle}}.{{.Service}}.Delete(projectID, key.Zone, key.Name) +{{- end}} + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} +{{end -}} + +{{- if .AggregatedList}} +// AggregatedList lists all resources of the given type across all locations. +func (g *{{.GCEWrapType}}) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*{{.FQObjectType}}, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "{{.Version}}", "{{.Service}}") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AggregatedList", + Version: meta.Version("{{.Version}}"), + Service: "{{.Service}}", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + + call := g.s.{{.VersionTitle}}.{{.Service}}.AggregatedList(projectID) + call.Context(ctx) + if fl != filter.None { + call.Filter(fl.String()) + } + + all := map[string][]*{{.FQObjectType}}{} + f := func(l *{{.ObjectAggregatedListType}}) error { + for k, v := range l.Items { + all[k] = append(all[k], v.{{.AggregatedListField}}...) + } + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} +{{- end}} + +{{- with .Methods -}} +{{- range .}} +// {{.Name}} is a method on {{.GCEWrapType}}. +func (g *{{.GCEWrapType}}) {{.FcnArgs}} { + projectID := g.s.ProjectRouter.ProjectID(ctx, "{{.Version}}", "{{.Service}}") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "{{.Name}}", + Version: meta.Version("{{.Version}}"), + Service: "{{.Service}}", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + {{- if eq .ReturnType "Operation"}} + return err + {{- else}} + return nil, err + {{- end}} + } +{{- if .KeyIsGlobal}} + call := g.s.{{.VersionTitle}}.{{.Service}}.{{.Name}}(projectID, key.Name {{.CallArgs}}) +{{- end -}} +{{- if .KeyIsRegional}} + call := g.s.{{.VersionTitle}}.{{.Service}}.{{.Name}}(projectID, key.Region, key.Name {{.CallArgs}}) +{{- end -}} +{{- if .KeyIsZonal}} + call := g.s.{{.VersionTitle}}.{{.Service}}.{{.Name}}(projectID, key.Zone, key.Name {{.CallArgs}}) +{{- end}} + call.Context(ctx) +{{- if eq .ReturnType "Operation"}} + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +{{- else}} + return call.Do() +{{- end}} +} +{{end -}} +{{- end}} +` + tmpl := template.Must(template.New("interface").Parse(text)) + for _, s := range meta.AllServices { + if err := tmpl.Execute(wr, s); err != nil { + panic(err) + } + } +} + +func genUnitTestHeader(wr io.Writer) { + const text = `/* +Copyright {{.Year}} 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. +*/ + +// This file was generated by "go run gen/main.go -mode test > gen_test.go". Do not edit +// directly. + +package cloud + +import ( + "context" + "reflect" + "testing" + + alpha "google.golang.org/api/compute/v0.alpha" + beta "google.golang.org/api/compute/v0.beta" + ga "google.golang.org/api/compute/v1" + + "{{.PackageRoot}}/filter" + "{{.PackageRoot}}/meta" +) + +const location = "location" +` + tmpl := template.Must(template.New("header").Parse(text)) + values := map[string]string{ + "Year": fmt.Sprintf("%v", time.Now().Year()), + "PackageRoot": packageRoot, + } + if err := tmpl.Execute(wr, values); err != nil { + panic(err) + } +} + +func genUnitTestServices(wr io.Writer) { + const text = ` +func Test{{.Service}}Group(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key +{{- if .HasAlpha}} + keyAlpha := meta.{{.Alpha.MakeKey "key-alpha" "location"}} + key = keyAlpha +{{- end}} +{{- if .HasBeta}} + keyBeta := meta.{{.Beta.MakeKey "key-beta" "location"}} + key = keyBeta +{{- end}} +{{- if .HasGA}} + keyGA := meta.{{.GA.MakeKey "key-ga" "location"}} + key = keyGA +{{- end}} + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. +{{- if .HasAlpha}}{{- if .Alpha.GenerateGet}} + if _, err := mock.Alpha{{.Service}}().Get(ctx, *key); err == nil { + t.Errorf("Alpha{{.Service}}().Get(%v, %v) = _, nil; want error", ctx, key) + } +{{- end}}{{- end}} +{{- if .HasBeta}}{{- if .Beta.GenerateGet}} + if _, err := mock.Beta{{.Service}}().Get(ctx, *key); err == nil { + t.Errorf("Beta{{.Service}}().Get(%v, %v) = _, nil; want error", ctx, key) + } +{{- end}}{{- end}} +{{- if .HasGA}}{{- if .GA.GenerateGet}} + if _, err := mock.{{.Service}}().Get(ctx, *key); err == nil { + t.Errorf("{{.Service}}().Get(%v, %v) = _, nil; want error", ctx, key) + } +{{- end}}{{- end}} + + // Insert. +{{- if .HasAlpha}}{{- if .Alpha.GenerateInsert}} + { + obj := &alpha.{{.Alpha.Object}}{} + if err := mock.Alpha{{.Service}}().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("Alpha{{.Service}}().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } +{{- end}}{{- end}} +{{- if .HasBeta}}{{- if .Beta.GenerateInsert}} + { + obj := &beta.{{.Beta.Object}}{} + if err := mock.Beta{{.Service}}().Insert(ctx, *keyBeta, obj); err != nil { + t.Errorf("Beta{{.Service}}().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } +{{- end}}{{- end}} +{{- if .HasGA}}{{- if .GA.GenerateInsert}} + { + obj := &ga.{{.GA.Object}}{} + if err := mock.{{.Service}}().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("{{.Service}}().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } +{{- end}}{{- end}} + + // Get across versions. +{{- if .HasAlpha}}{{- if .Alpha.GenerateInsert}} + if obj, err := mock.Alpha{{.Service}}().Get(ctx, *key); err != nil { + t.Errorf("Alpha{{.Service}}().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } +{{- end}}{{- end}} +{{- if .HasBeta}}{{- if .Beta.GenerateInsert}} + if obj, err := mock.Beta{{.Service}}().Get(ctx, *key); err != nil { + t.Errorf("Beta{{.Service}}().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } +{{- end}}{{- end}} +{{- if .HasGA}}{{- if .GA.GenerateInsert}} + if obj, err := mock.{{.Service}}().Get(ctx, *key); err != nil { + t.Errorf("{{.Service}}().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } +{{- end}}{{- end}} + + // List. +{{- if .HasAlpha}} + mock.MockAlpha{{.Service}}.Objects[*keyAlpha] = mock.MockAlpha{{.Service}}.Obj(&alpha.{{.Alpha.Object}}{Name: keyAlpha.Name}) +{{- end}} +{{- if .HasBeta}} + mock.MockBeta{{.Service}}.Objects[*keyBeta] = mock.MockBeta{{.Service}}.Obj(&beta.{{.Beta.Object}}{Name: keyBeta.Name}) +{{- end}} +{{- if .HasGA}} + mock.Mock{{.Service}}.Objects[*keyGA] = mock.Mock{{.Service}}.Obj(&ga.{{.GA.Object}}{Name: keyGA.Name}) +{{- end}} + want := map[string]bool{ +{{- if .HasAlpha}} + "key-alpha": true, +{{- end}} +{{- if .HasBeta}} + "key-beta": true, +{{- end}} +{{- if .HasGA}} + "key-ga": true, +{{- end}} + } + _ = want // ignore unused variables. + +{{- if .HasAlpha}}{{- if .Alpha.GenerateList}} + { + {{- if .Alpha.KeyIsGlobal }} + objs, err := mock.Alpha{{.Service}}().List(ctx, filter.None) + {{- else}} + objs, err := mock.Alpha{{.Service}}().List(ctx, location, filter.None) + {{- end}} + if err != nil { + t.Errorf("Alpha{{.Service}}().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("Alpha{{.Service}}().List(); got %+v, want %+v", got, want) + } + } + } +{{- end}}{{- end}} +{{- if .HasBeta}}{{- if .Beta.GenerateList}} + { + {{- if .Beta.KeyIsGlobal }} + objs, err := mock.Beta{{.Service}}().List(ctx, filter.None) + {{- else}} + objs, err := mock.Beta{{.Service}}().List(ctx, location, filter.None) + {{- end}} + if err != nil { + t.Errorf("Beta{{.Service}}().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("Alpha{{.Service}}().List(); got %+v, want %+v", got, want) + } + } + } +{{- end}}{{- end}} +{{- if .HasGA}}{{- if .GA.GenerateList}} + { + {{- if .GA.KeyIsGlobal }} + objs, err := mock.{{.Service}}().List(ctx, filter.None) + {{- else}} + objs, err := mock.{{.Service}}().List(ctx, location, filter.None) + {{- end}} + if err != nil { + t.Errorf("{{.Service}}().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("Alpha{{.Service}}().List(); got %+v, want %+v", got, want) + } + } + } +{{- end}}{{- end}} + + // Delete across versions. +{{- if .HasAlpha}}{{- if .Alpha.GenerateDelete}} + if err := mock.Alpha{{.Service}}().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("Alpha{{.Service}}().Delete(%v, %v) = %v; want nil", ctx, key, err) + } +{{- end}}{{- end}} +{{- if .HasBeta}}{{- if .Beta.GenerateDelete}} + if err := mock.Beta{{.Service}}().Delete(ctx, *keyBeta); err != nil { + t.Errorf("Beta{{.Service}}().Delete(%v, %v) = %v; want nil", ctx, key, err) + } +{{- end}}{{- end}} +{{- if .HasGA}}{{- if .GA.GenerateDelete}} + if err := mock.{{.Service}}().Delete(ctx, *keyGA); err != nil { + t.Errorf("{{.Service}}().Delete(%v, %v) = %v; want nil", ctx, key, err) + } +{{- end}}{{- end}} + + // Delete not found. +{{- if .HasAlpha}}{{- if .Alpha.GenerateDelete}} + if err := mock.Alpha{{.Service}}().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("Alpha{{.Service}}().Delete(%v, %v) = nil; want error", ctx, key) + } +{{- end}}{{- end}} +{{- if .HasBeta}}{{- if .Beta.GenerateDelete}} + if err := mock.Beta{{.Service}}().Delete(ctx, *keyBeta); err == nil { + t.Errorf("Beta{{.Service}}().Delete(%v, %v) = nil; want error", ctx, key) + } +{{- end}}{{- end}} +{{- if .HasGA}}{{- if .GA.GenerateDelete}} + if err := mock.{{.Service}}().Delete(ctx, *keyGA); err == nil { + t.Errorf("{{.Service}}().Delete(%v, %v) = nil; want error", ctx, key) + } +{{- end}}{{- end}} +} +` + tmpl := template.Must(template.New("unittest").Parse(text)) + for _, s := range meta.AllServicesByGroup { + if err := tmpl.Execute(wr, s); err != nil { + panic(err) + } + } +} + +func main() { + flag.Parse() + + out := &bytes.Buffer{} + + switch flags.mode { + case "src": + genHeader(out) + genStubs(out) + genTypes(out) + case "test": + genUnitTestHeader(out) + genUnitTestServices(out) + default: + glog.Fatalf("Invalid -mode: %q", flags.mode) + } + + if flags.gofmt { + fmt.Print(gofmtContent(out)) + } else { + fmt.Print(out.String()) + } +} From 329e0b1cb57178196f8854bc67573bc4d2813454 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:35:41 -0800 Subject: [PATCH 07/18] support interfaces for the generated code --- .../providers/gce/cloud/project.go | 44 +++++++++++ .../providers/gce/cloud/ratelimit.go | 67 ++++++++++++++++ .../providers/gce/cloud/service.go | 79 +++++++++++++++++++ 3 files changed, 190 insertions(+) create mode 100644 pkg/cloudprovider/providers/gce/cloud/project.go create mode 100644 pkg/cloudprovider/providers/gce/cloud/ratelimit.go create mode 100644 pkg/cloudprovider/providers/gce/cloud/service.go diff --git a/pkg/cloudprovider/providers/gce/cloud/project.go b/pkg/cloudprovider/providers/gce/cloud/project.go new file mode 100644 index 00000000000..74299e4a23e --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/project.go @@ -0,0 +1,44 @@ +/* +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 cloud + +import ( + "context" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" +) + +// ProjectRouter routes service calls to the appropriate GCE project. +type ProjectRouter interface { + // ProjectID returns the project ID (non-numeric) to be used for a call + // to an API (version,service). Example tuples: ("ga", "ForwardingRules"), + // ("alpha", "GlobalAddresses"). + // + // This allows for plumbing different service calls to the appropriate + // project, for instance, networking services to a separate project + // than instance management. + ProjectID(ctx context.Context, version meta.Version, service string) string +} + +// SingleProjectRouter routes all service calls to the same project ID. +type SingleProjectRouter struct { + ID string +} + +func (r *SingleProjectRouter) ProjectID(ctx context.Context, version meta.Version, service string) string { + return r.ID +} diff --git a/pkg/cloudprovider/providers/gce/cloud/ratelimit.go b/pkg/cloudprovider/providers/gce/cloud/ratelimit.go new file mode 100644 index 00000000000..948f1d36d89 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/ratelimit.go @@ -0,0 +1,67 @@ +/* +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 cloud + +import ( + "context" + "time" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" +) + +// RateLimitKey is a key identifying the operation to be rate limited. The rate limit +// queue will be determined based on the contents of RateKey. +type RateLimitKey struct { + // ProjectID is the non-numeric ID of the project. + ProjectID string + // Operation is the specific method being invoked (e.g. "Get", "List"). + Operation string + // Version is the API version of the call. + Version meta.Version + // Service is the service being invoked (e.g. "Firewalls", "BackendServices") + Service string +} + +// RateLimiter is the interface for a rate limiting policy. +type RateLimiter interface { + // Accept uses the RateLimitKey to derive a sleep time for the calling + // goroutine. This call will block until the operation is ready for + // execution. + // + // Accept returns an error if the given context ctx was canceled + // while waiting for acceptance into the queue. + Accept(ctx context.Context, key *RateLimitKey) error +} + +// NopRateLimiter is a rate limiter that performs no rate limiting. +type NopRateLimiter struct { +} + +func (*NopRateLimiter) Accept(ctx context.Context, key *RateLimitKey) error { + // Rate limit polling of the Operation status to avoid hammering GCE + // for the status of an operation. + const pollTime = time.Duration(1) * time.Second + if key.Operation == "Get" && key.Service == "Operations" { + select { + case <-time.NewTimer(pollTime).C: + break + case <-ctx.Done(): + return ctx.Err() + } + } + return nil +} diff --git a/pkg/cloudprovider/providers/gce/cloud/service.go b/pkg/cloudprovider/providers/gce/cloud/service.go new file mode 100644 index 00000000000..8a6c0a6cf95 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/service.go @@ -0,0 +1,79 @@ +/* +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 cloud + +import ( + "context" + "fmt" + + alpha "google.golang.org/api/compute/v0.alpha" + beta "google.golang.org/api/compute/v0.beta" + ga "google.golang.org/api/compute/v1" +) + +// Service is the top-level adapter for all of the different compute API +// versions. +type Service struct { + GA *ga.Service + Alpha *alpha.Service + Beta *beta.Service + ProjectRouter ProjectRouter + RateLimiter RateLimiter +} + +// wrapOperation wraps a GCE anyOP in a version generic operation type. +func (g *Service) wrapOperation(anyOp interface{}) (operation, error) { + switch o := anyOp.(type) { + case *ga.Operation: + r, err := ParseResourceURL(o.SelfLink) + if err != nil { + return nil, err + } + return &gaOperation{g, o, r.ProjectID}, nil + case *alpha.Operation: + r, err := ParseResourceURL(o.SelfLink) + if err != nil { + return nil, err + } + return &alphaOperation{g, o, r.ProjectID}, nil + case *beta.Operation: + r, err := ParseResourceURL(o.SelfLink) + if err != nil { + return nil, err + } + return &betaOperation{g, o, r.ProjectID}, nil + default: + return nil, fmt.Errorf("invalid type %T", anyOp) + } +} + +// WaitForCompletion of a long running operation. This will poll the state of +// GCE for the completion status of the given operation. genericOp can be one +// of alpha, beta, ga Operation types. +func (g *Service) WaitForCompletion(ctx context.Context, genericOp interface{}) error { + op, err := g.wrapOperation(genericOp) + if err != nil { + return err + } + for done, err := op.isDone(ctx); !done; done, err = op.isDone(ctx) { + if err != nil { + return err + } + g.RateLimiter.Accept(ctx, op.rateLimitKey()) + } + return nil +} From e230bd967b3cab2a264cbf59b03660dcd24a130c Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:35:58 -0800 Subject: [PATCH 08/18] Generated code (see gen/main.go for the source) --- pkg/cloudprovider/providers/gce/cloud/gen.go | 10351 ++++++++++++++++ .../providers/gce/cloud/gen_test.go | 1749 +++ 2 files changed, 12100 insertions(+) create mode 100644 pkg/cloudprovider/providers/gce/cloud/gen.go create mode 100644 pkg/cloudprovider/providers/gce/cloud/gen_test.go diff --git a/pkg/cloudprovider/providers/gce/cloud/gen.go b/pkg/cloudprovider/providers/gce/cloud/gen.go new file mode 100644 index 00000000000..ef7a2c62eaf --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/gen.go @@ -0,0 +1,10351 @@ +/* +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. +*/ + +// This file was generated by "go run gen/main.go > gen.go". Do not edit +// directly. + +package cloud + +import ( + "context" + "fmt" + "net/http" + "sync" + + "github.com/golang/glog" + "google.golang.org/api/googleapi" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/filter" + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" + + alpha "google.golang.org/api/compute/v0.alpha" + beta "google.golang.org/api/compute/v0.beta" + ga "google.golang.org/api/compute/v1" +) + +// Cloud is an interface for the GCE compute API. +type Cloud interface { + Addresses() Addresses + AlphaAddresses() AlphaAddresses + BetaAddresses() BetaAddresses + GlobalAddresses() GlobalAddresses + BackendServices() BackendServices + AlphaBackendServices() AlphaBackendServices + AlphaRegionBackendServices() AlphaRegionBackendServices + Disks() Disks + AlphaDisks() AlphaDisks + AlphaRegionDisks() AlphaRegionDisks + Firewalls() Firewalls + ForwardingRules() ForwardingRules + AlphaForwardingRules() AlphaForwardingRules + GlobalForwardingRules() GlobalForwardingRules + HealthChecks() HealthChecks + AlphaHealthChecks() AlphaHealthChecks + HttpHealthChecks() HttpHealthChecks + HttpsHealthChecks() HttpsHealthChecks + InstanceGroups() InstanceGroups + Instances() Instances + BetaInstances() BetaInstances + AlphaInstances() AlphaInstances + AlphaNetworkEndpointGroups() AlphaNetworkEndpointGroups + Projects() Projects + Regions() Regions + Routes() Routes + SslCertificates() SslCertificates + TargetHttpProxies() TargetHttpProxies + TargetHttpsProxies() TargetHttpsProxies + TargetPools() TargetPools + UrlMaps() UrlMaps + Zones() Zones +} + +// NewGCE returns a GCE. +func NewGCE(s *Service) *GCE { + g := &GCE{ + gceAddresses: &GCEAddresses{s}, + gceAlphaAddresses: &GCEAlphaAddresses{s}, + gceBetaAddresses: &GCEBetaAddresses{s}, + gceGlobalAddresses: &GCEGlobalAddresses{s}, + gceBackendServices: &GCEBackendServices{s}, + gceAlphaBackendServices: &GCEAlphaBackendServices{s}, + gceAlphaRegionBackendServices: &GCEAlphaRegionBackendServices{s}, + gceDisks: &GCEDisks{s}, + gceAlphaDisks: &GCEAlphaDisks{s}, + gceAlphaRegionDisks: &GCEAlphaRegionDisks{s}, + gceFirewalls: &GCEFirewalls{s}, + gceForwardingRules: &GCEForwardingRules{s}, + gceAlphaForwardingRules: &GCEAlphaForwardingRules{s}, + gceGlobalForwardingRules: &GCEGlobalForwardingRules{s}, + gceHealthChecks: &GCEHealthChecks{s}, + gceAlphaHealthChecks: &GCEAlphaHealthChecks{s}, + gceHttpHealthChecks: &GCEHttpHealthChecks{s}, + gceHttpsHealthChecks: &GCEHttpsHealthChecks{s}, + gceInstanceGroups: &GCEInstanceGroups{s}, + gceInstances: &GCEInstances{s}, + gceBetaInstances: &GCEBetaInstances{s}, + gceAlphaInstances: &GCEAlphaInstances{s}, + gceAlphaNetworkEndpointGroups: &GCEAlphaNetworkEndpointGroups{s}, + gceProjects: &GCEProjects{s}, + gceRegions: &GCERegions{s}, + gceRoutes: &GCERoutes{s}, + gceSslCertificates: &GCESslCertificates{s}, + gceTargetHttpProxies: &GCETargetHttpProxies{s}, + gceTargetHttpsProxies: &GCETargetHttpsProxies{s}, + gceTargetPools: &GCETargetPools{s}, + gceUrlMaps: &GCEUrlMaps{s}, + gceZones: &GCEZones{s}, + } + return g +} + +// GCE implements Cloud. +var _ Cloud = (*GCE)(nil) + +// GCE is the golang adapter for the compute APIs. +type GCE struct { + gceAddresses *GCEAddresses + gceAlphaAddresses *GCEAlphaAddresses + gceBetaAddresses *GCEBetaAddresses + gceGlobalAddresses *GCEGlobalAddresses + gceBackendServices *GCEBackendServices + gceAlphaBackendServices *GCEAlphaBackendServices + gceAlphaRegionBackendServices *GCEAlphaRegionBackendServices + gceDisks *GCEDisks + gceAlphaDisks *GCEAlphaDisks + gceAlphaRegionDisks *GCEAlphaRegionDisks + gceFirewalls *GCEFirewalls + gceForwardingRules *GCEForwardingRules + gceAlphaForwardingRules *GCEAlphaForwardingRules + gceGlobalForwardingRules *GCEGlobalForwardingRules + gceHealthChecks *GCEHealthChecks + gceAlphaHealthChecks *GCEAlphaHealthChecks + gceHttpHealthChecks *GCEHttpHealthChecks + gceHttpsHealthChecks *GCEHttpsHealthChecks + gceInstanceGroups *GCEInstanceGroups + gceInstances *GCEInstances + gceBetaInstances *GCEBetaInstances + gceAlphaInstances *GCEAlphaInstances + gceAlphaNetworkEndpointGroups *GCEAlphaNetworkEndpointGroups + gceProjects *GCEProjects + gceRegions *GCERegions + gceRoutes *GCERoutes + gceSslCertificates *GCESslCertificates + gceTargetHttpProxies *GCETargetHttpProxies + gceTargetHttpsProxies *GCETargetHttpsProxies + gceTargetPools *GCETargetPools + gceUrlMaps *GCEUrlMaps + gceZones *GCEZones +} + +func (gce *GCE) Addresses() Addresses { + return gce.gceAddresses +} +func (gce *GCE) AlphaAddresses() AlphaAddresses { + return gce.gceAlphaAddresses +} +func (gce *GCE) BetaAddresses() BetaAddresses { + return gce.gceBetaAddresses +} +func (gce *GCE) GlobalAddresses() GlobalAddresses { + return gce.gceGlobalAddresses +} +func (gce *GCE) BackendServices() BackendServices { + return gce.gceBackendServices +} +func (gce *GCE) AlphaBackendServices() AlphaBackendServices { + return gce.gceAlphaBackendServices +} +func (gce *GCE) AlphaRegionBackendServices() AlphaRegionBackendServices { + return gce.gceAlphaRegionBackendServices +} +func (gce *GCE) Disks() Disks { + return gce.gceDisks +} +func (gce *GCE) AlphaDisks() AlphaDisks { + return gce.gceAlphaDisks +} +func (gce *GCE) AlphaRegionDisks() AlphaRegionDisks { + return gce.gceAlphaRegionDisks +} +func (gce *GCE) Firewalls() Firewalls { + return gce.gceFirewalls +} +func (gce *GCE) ForwardingRules() ForwardingRules { + return gce.gceForwardingRules +} +func (gce *GCE) AlphaForwardingRules() AlphaForwardingRules { + return gce.gceAlphaForwardingRules +} +func (gce *GCE) GlobalForwardingRules() GlobalForwardingRules { + return gce.gceGlobalForwardingRules +} +func (gce *GCE) HealthChecks() HealthChecks { + return gce.gceHealthChecks +} +func (gce *GCE) AlphaHealthChecks() AlphaHealthChecks { + return gce.gceAlphaHealthChecks +} +func (gce *GCE) HttpHealthChecks() HttpHealthChecks { + return gce.gceHttpHealthChecks +} +func (gce *GCE) HttpsHealthChecks() HttpsHealthChecks { + return gce.gceHttpsHealthChecks +} +func (gce *GCE) InstanceGroups() InstanceGroups { + return gce.gceInstanceGroups +} +func (gce *GCE) Instances() Instances { + return gce.gceInstances +} +func (gce *GCE) BetaInstances() BetaInstances { + return gce.gceBetaInstances +} +func (gce *GCE) AlphaInstances() AlphaInstances { + return gce.gceAlphaInstances +} +func (gce *GCE) AlphaNetworkEndpointGroups() AlphaNetworkEndpointGroups { + return gce.gceAlphaNetworkEndpointGroups +} +func (gce *GCE) Projects() Projects { + return gce.gceProjects +} +func (gce *GCE) Regions() Regions { + return gce.gceRegions +} +func (gce *GCE) Routes() Routes { + return gce.gceRoutes +} +func (gce *GCE) SslCertificates() SslCertificates { + return gce.gceSslCertificates +} +func (gce *GCE) TargetHttpProxies() TargetHttpProxies { + return gce.gceTargetHttpProxies +} +func (gce *GCE) TargetHttpsProxies() TargetHttpsProxies { + return gce.gceTargetHttpsProxies +} +func (gce *GCE) TargetPools() TargetPools { + return gce.gceTargetPools +} +func (gce *GCE) UrlMaps() UrlMaps { + return gce.gceUrlMaps +} +func (gce *GCE) Zones() Zones { + return gce.gceZones +} + +// NewMockGCE returns a new mock for GCE. +func NewMockGCE() *MockGCE { + mockAddressesObjs := map[meta.Key]*MockAddressesObj{} + mockBackendServicesObjs := map[meta.Key]*MockBackendServicesObj{} + mockDisksObjs := map[meta.Key]*MockDisksObj{} + mockFirewallsObjs := map[meta.Key]*MockFirewallsObj{} + mockForwardingRulesObjs := map[meta.Key]*MockForwardingRulesObj{} + mockGlobalAddressesObjs := map[meta.Key]*MockGlobalAddressesObj{} + mockGlobalForwardingRulesObjs := map[meta.Key]*MockGlobalForwardingRulesObj{} + mockHealthChecksObjs := map[meta.Key]*MockHealthChecksObj{} + mockHttpHealthChecksObjs := map[meta.Key]*MockHttpHealthChecksObj{} + mockHttpsHealthChecksObjs := map[meta.Key]*MockHttpsHealthChecksObj{} + mockInstanceGroupsObjs := map[meta.Key]*MockInstanceGroupsObj{} + mockInstancesObjs := map[meta.Key]*MockInstancesObj{} + mockNetworkEndpointGroupsObjs := map[meta.Key]*MockNetworkEndpointGroupsObj{} + mockProjectsObjs := map[meta.Key]*MockProjectsObj{} + mockRegionBackendServicesObjs := map[meta.Key]*MockRegionBackendServicesObj{} + mockRegionDisksObjs := map[meta.Key]*MockRegionDisksObj{} + mockRegionsObjs := map[meta.Key]*MockRegionsObj{} + mockRoutesObjs := map[meta.Key]*MockRoutesObj{} + mockSslCertificatesObjs := map[meta.Key]*MockSslCertificatesObj{} + mockTargetHttpProxiesObjs := map[meta.Key]*MockTargetHttpProxiesObj{} + mockTargetHttpsProxiesObjs := map[meta.Key]*MockTargetHttpsProxiesObj{} + mockTargetPoolsObjs := map[meta.Key]*MockTargetPoolsObj{} + mockUrlMapsObjs := map[meta.Key]*MockUrlMapsObj{} + mockZonesObjs := map[meta.Key]*MockZonesObj{} + + mock := &MockGCE{ + MockAddresses: NewMockAddresses(mockAddressesObjs), + MockAlphaAddresses: NewMockAlphaAddresses(mockAddressesObjs), + MockBetaAddresses: NewMockBetaAddresses(mockAddressesObjs), + MockGlobalAddresses: NewMockGlobalAddresses(mockGlobalAddressesObjs), + MockBackendServices: NewMockBackendServices(mockBackendServicesObjs), + MockAlphaBackendServices: NewMockAlphaBackendServices(mockBackendServicesObjs), + MockAlphaRegionBackendServices: NewMockAlphaRegionBackendServices(mockRegionBackendServicesObjs), + MockDisks: NewMockDisks(mockDisksObjs), + MockAlphaDisks: NewMockAlphaDisks(mockDisksObjs), + MockAlphaRegionDisks: NewMockAlphaRegionDisks(mockRegionDisksObjs), + MockFirewalls: NewMockFirewalls(mockFirewallsObjs), + MockForwardingRules: NewMockForwardingRules(mockForwardingRulesObjs), + MockAlphaForwardingRules: NewMockAlphaForwardingRules(mockForwardingRulesObjs), + MockGlobalForwardingRules: NewMockGlobalForwardingRules(mockGlobalForwardingRulesObjs), + MockHealthChecks: NewMockHealthChecks(mockHealthChecksObjs), + MockAlphaHealthChecks: NewMockAlphaHealthChecks(mockHealthChecksObjs), + MockHttpHealthChecks: NewMockHttpHealthChecks(mockHttpHealthChecksObjs), + MockHttpsHealthChecks: NewMockHttpsHealthChecks(mockHttpsHealthChecksObjs), + MockInstanceGroups: NewMockInstanceGroups(mockInstanceGroupsObjs), + MockInstances: NewMockInstances(mockInstancesObjs), + MockBetaInstances: NewMockBetaInstances(mockInstancesObjs), + MockAlphaInstances: NewMockAlphaInstances(mockInstancesObjs), + MockAlphaNetworkEndpointGroups: NewMockAlphaNetworkEndpointGroups(mockNetworkEndpointGroupsObjs), + MockProjects: NewMockProjects(mockProjectsObjs), + MockRegions: NewMockRegions(mockRegionsObjs), + MockRoutes: NewMockRoutes(mockRoutesObjs), + MockSslCertificates: NewMockSslCertificates(mockSslCertificatesObjs), + MockTargetHttpProxies: NewMockTargetHttpProxies(mockTargetHttpProxiesObjs), + MockTargetHttpsProxies: NewMockTargetHttpsProxies(mockTargetHttpsProxiesObjs), + MockTargetPools: NewMockTargetPools(mockTargetPoolsObjs), + MockUrlMaps: NewMockUrlMaps(mockUrlMapsObjs), + MockZones: NewMockZones(mockZonesObjs), + } + return mock +} + +// MockGCE implements Cloud. +var _ Cloud = (*MockGCE)(nil) + +// MockGCE is the mock for the compute API. +type MockGCE struct { + MockAddresses *MockAddresses + MockAlphaAddresses *MockAlphaAddresses + MockBetaAddresses *MockBetaAddresses + MockGlobalAddresses *MockGlobalAddresses + MockBackendServices *MockBackendServices + MockAlphaBackendServices *MockAlphaBackendServices + MockAlphaRegionBackendServices *MockAlphaRegionBackendServices + MockDisks *MockDisks + MockAlphaDisks *MockAlphaDisks + MockAlphaRegionDisks *MockAlphaRegionDisks + MockFirewalls *MockFirewalls + MockForwardingRules *MockForwardingRules + MockAlphaForwardingRules *MockAlphaForwardingRules + MockGlobalForwardingRules *MockGlobalForwardingRules + MockHealthChecks *MockHealthChecks + MockAlphaHealthChecks *MockAlphaHealthChecks + MockHttpHealthChecks *MockHttpHealthChecks + MockHttpsHealthChecks *MockHttpsHealthChecks + MockInstanceGroups *MockInstanceGroups + MockInstances *MockInstances + MockBetaInstances *MockBetaInstances + MockAlphaInstances *MockAlphaInstances + MockAlphaNetworkEndpointGroups *MockAlphaNetworkEndpointGroups + MockProjects *MockProjects + MockRegions *MockRegions + MockRoutes *MockRoutes + MockSslCertificates *MockSslCertificates + MockTargetHttpProxies *MockTargetHttpProxies + MockTargetHttpsProxies *MockTargetHttpsProxies + MockTargetPools *MockTargetPools + MockUrlMaps *MockUrlMaps + MockZones *MockZones +} + +func (mock *MockGCE) Addresses() Addresses { + return mock.MockAddresses +} + +func (mock *MockGCE) AlphaAddresses() AlphaAddresses { + return mock.MockAlphaAddresses +} + +func (mock *MockGCE) BetaAddresses() BetaAddresses { + return mock.MockBetaAddresses +} + +func (mock *MockGCE) GlobalAddresses() GlobalAddresses { + return mock.MockGlobalAddresses +} + +func (mock *MockGCE) BackendServices() BackendServices { + return mock.MockBackendServices +} + +func (mock *MockGCE) AlphaBackendServices() AlphaBackendServices { + return mock.MockAlphaBackendServices +} + +func (mock *MockGCE) AlphaRegionBackendServices() AlphaRegionBackendServices { + return mock.MockAlphaRegionBackendServices +} + +func (mock *MockGCE) Disks() Disks { + return mock.MockDisks +} + +func (mock *MockGCE) AlphaDisks() AlphaDisks { + return mock.MockAlphaDisks +} + +func (mock *MockGCE) AlphaRegionDisks() AlphaRegionDisks { + return mock.MockAlphaRegionDisks +} + +func (mock *MockGCE) Firewalls() Firewalls { + return mock.MockFirewalls +} + +func (mock *MockGCE) ForwardingRules() ForwardingRules { + return mock.MockForwardingRules +} + +func (mock *MockGCE) AlphaForwardingRules() AlphaForwardingRules { + return mock.MockAlphaForwardingRules +} + +func (mock *MockGCE) GlobalForwardingRules() GlobalForwardingRules { + return mock.MockGlobalForwardingRules +} + +func (mock *MockGCE) HealthChecks() HealthChecks { + return mock.MockHealthChecks +} + +func (mock *MockGCE) AlphaHealthChecks() AlphaHealthChecks { + return mock.MockAlphaHealthChecks +} + +func (mock *MockGCE) HttpHealthChecks() HttpHealthChecks { + return mock.MockHttpHealthChecks +} + +func (mock *MockGCE) HttpsHealthChecks() HttpsHealthChecks { + return mock.MockHttpsHealthChecks +} + +func (mock *MockGCE) InstanceGroups() InstanceGroups { + return mock.MockInstanceGroups +} + +func (mock *MockGCE) Instances() Instances { + return mock.MockInstances +} + +func (mock *MockGCE) BetaInstances() BetaInstances { + return mock.MockBetaInstances +} + +func (mock *MockGCE) AlphaInstances() AlphaInstances { + return mock.MockAlphaInstances +} + +func (mock *MockGCE) AlphaNetworkEndpointGroups() AlphaNetworkEndpointGroups { + return mock.MockAlphaNetworkEndpointGroups +} + +func (mock *MockGCE) Projects() Projects { + return mock.MockProjects +} + +func (mock *MockGCE) Regions() Regions { + return mock.MockRegions +} + +func (mock *MockGCE) Routes() Routes { + return mock.MockRoutes +} + +func (mock *MockGCE) SslCertificates() SslCertificates { + return mock.MockSslCertificates +} + +func (mock *MockGCE) TargetHttpProxies() TargetHttpProxies { + return mock.MockTargetHttpProxies +} + +func (mock *MockGCE) TargetHttpsProxies() TargetHttpsProxies { + return mock.MockTargetHttpsProxies +} + +func (mock *MockGCE) TargetPools() TargetPools { + return mock.MockTargetPools +} + +func (mock *MockGCE) UrlMaps() UrlMaps { + return mock.MockUrlMaps +} + +func (mock *MockGCE) Zones() Zones { + return mock.MockZones +} + +// MockAddressesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockAddressesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockAddressesObj) ToAlpha() *alpha.Address { + if ret, ok := m.Obj.(*alpha.Address); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.Address{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.Address via JSON: %v", m.Obj, err) + } + return ret +} + +// ToBeta retrieves the given version of the object. +func (m *MockAddressesObj) ToBeta() *beta.Address { + if ret, ok := m.Obj.(*beta.Address); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &beta.Address{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *beta.Address via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockAddressesObj) ToGA() *ga.Address { + if ret, ok := m.Obj.(*ga.Address); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Address{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Address via JSON: %v", m.Obj, err) + } + return ret +} + +// MockBackendServicesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockBackendServicesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockBackendServicesObj) ToAlpha() *alpha.BackendService { + if ret, ok := m.Obj.(*alpha.BackendService); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.BackendService{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.BackendService via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockBackendServicesObj) ToGA() *ga.BackendService { + if ret, ok := m.Obj.(*ga.BackendService); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.BackendService{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.BackendService via JSON: %v", m.Obj, err) + } + return ret +} + +// MockDisksObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockDisksObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockDisksObj) ToAlpha() *alpha.Disk { + if ret, ok := m.Obj.(*alpha.Disk); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.Disk{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.Disk via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockDisksObj) ToGA() *ga.Disk { + if ret, ok := m.Obj.(*ga.Disk); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Disk{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Disk via JSON: %v", m.Obj, err) + } + return ret +} + +// MockFirewallsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockFirewallsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockFirewallsObj) ToGA() *ga.Firewall { + if ret, ok := m.Obj.(*ga.Firewall); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Firewall{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Firewall via JSON: %v", m.Obj, err) + } + return ret +} + +// MockForwardingRulesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockForwardingRulesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockForwardingRulesObj) ToAlpha() *alpha.ForwardingRule { + if ret, ok := m.Obj.(*alpha.ForwardingRule); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.ForwardingRule{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.ForwardingRule via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockForwardingRulesObj) ToGA() *ga.ForwardingRule { + if ret, ok := m.Obj.(*ga.ForwardingRule); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.ForwardingRule{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.ForwardingRule via JSON: %v", m.Obj, err) + } + return ret +} + +// MockGlobalAddressesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockGlobalAddressesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockGlobalAddressesObj) ToGA() *ga.Address { + if ret, ok := m.Obj.(*ga.Address); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Address{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Address via JSON: %v", m.Obj, err) + } + return ret +} + +// MockGlobalForwardingRulesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockGlobalForwardingRulesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockGlobalForwardingRulesObj) ToGA() *ga.ForwardingRule { + if ret, ok := m.Obj.(*ga.ForwardingRule); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.ForwardingRule{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.ForwardingRule via JSON: %v", m.Obj, err) + } + return ret +} + +// MockHealthChecksObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockHealthChecksObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockHealthChecksObj) ToAlpha() *alpha.HealthCheck { + if ret, ok := m.Obj.(*alpha.HealthCheck); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.HealthCheck{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.HealthCheck via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockHealthChecksObj) ToGA() *ga.HealthCheck { + if ret, ok := m.Obj.(*ga.HealthCheck); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.HealthCheck{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.HealthCheck via JSON: %v", m.Obj, err) + } + return ret +} + +// MockHttpHealthChecksObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockHttpHealthChecksObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockHttpHealthChecksObj) ToGA() *ga.HttpHealthCheck { + if ret, ok := m.Obj.(*ga.HttpHealthCheck); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.HttpHealthCheck{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.HttpHealthCheck via JSON: %v", m.Obj, err) + } + return ret +} + +// MockHttpsHealthChecksObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockHttpsHealthChecksObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockHttpsHealthChecksObj) ToGA() *ga.HttpsHealthCheck { + if ret, ok := m.Obj.(*ga.HttpsHealthCheck); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.HttpsHealthCheck{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.HttpsHealthCheck via JSON: %v", m.Obj, err) + } + return ret +} + +// MockInstanceGroupsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockInstanceGroupsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockInstanceGroupsObj) ToGA() *ga.InstanceGroup { + if ret, ok := m.Obj.(*ga.InstanceGroup); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.InstanceGroup{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.InstanceGroup via JSON: %v", m.Obj, err) + } + return ret +} + +// MockInstancesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockInstancesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockInstancesObj) ToAlpha() *alpha.Instance { + if ret, ok := m.Obj.(*alpha.Instance); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.Instance{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.Instance via JSON: %v", m.Obj, err) + } + return ret +} + +// ToBeta retrieves the given version of the object. +func (m *MockInstancesObj) ToBeta() *beta.Instance { + if ret, ok := m.Obj.(*beta.Instance); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &beta.Instance{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *beta.Instance via JSON: %v", m.Obj, err) + } + return ret +} + +// ToGA retrieves the given version of the object. +func (m *MockInstancesObj) ToGA() *ga.Instance { + if ret, ok := m.Obj.(*ga.Instance); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Instance{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Instance via JSON: %v", m.Obj, err) + } + return ret +} + +// MockNetworkEndpointGroupsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockNetworkEndpointGroupsObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockNetworkEndpointGroupsObj) ToAlpha() *alpha.NetworkEndpointGroup { + if ret, ok := m.Obj.(*alpha.NetworkEndpointGroup); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.NetworkEndpointGroup{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.NetworkEndpointGroup via JSON: %v", m.Obj, err) + } + return ret +} + +// MockProjectsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockProjectsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockProjectsObj) ToGA() *ga.Project { + if ret, ok := m.Obj.(*ga.Project); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Project{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Project via JSON: %v", m.Obj, err) + } + return ret +} + +// MockRegionBackendServicesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockRegionBackendServicesObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockRegionBackendServicesObj) ToAlpha() *alpha.BackendService { + if ret, ok := m.Obj.(*alpha.BackendService); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.BackendService{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.BackendService via JSON: %v", m.Obj, err) + } + return ret +} + +// MockRegionDisksObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockRegionDisksObj struct { + Obj interface{} +} + +// ToAlpha retrieves the given version of the object. +func (m *MockRegionDisksObj) ToAlpha() *alpha.Disk { + if ret, ok := m.Obj.(*alpha.Disk); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &alpha.Disk{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *alpha.Disk via JSON: %v", m.Obj, err) + } + return ret +} + +// MockRegionsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockRegionsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockRegionsObj) ToGA() *ga.Region { + if ret, ok := m.Obj.(*ga.Region); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Region{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Region via JSON: %v", m.Obj, err) + } + return ret +} + +// MockRoutesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockRoutesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockRoutesObj) ToGA() *ga.Route { + if ret, ok := m.Obj.(*ga.Route); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Route{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Route via JSON: %v", m.Obj, err) + } + return ret +} + +// MockSslCertificatesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockSslCertificatesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockSslCertificatesObj) ToGA() *ga.SslCertificate { + if ret, ok := m.Obj.(*ga.SslCertificate); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.SslCertificate{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.SslCertificate via JSON: %v", m.Obj, err) + } + return ret +} + +// MockTargetHttpProxiesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockTargetHttpProxiesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockTargetHttpProxiesObj) ToGA() *ga.TargetHttpProxy { + if ret, ok := m.Obj.(*ga.TargetHttpProxy); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.TargetHttpProxy{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.TargetHttpProxy via JSON: %v", m.Obj, err) + } + return ret +} + +// MockTargetHttpsProxiesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockTargetHttpsProxiesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockTargetHttpsProxiesObj) ToGA() *ga.TargetHttpsProxy { + if ret, ok := m.Obj.(*ga.TargetHttpsProxy); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.TargetHttpsProxy{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.TargetHttpsProxy via JSON: %v", m.Obj, err) + } + return ret +} + +// MockTargetPoolsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockTargetPoolsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockTargetPoolsObj) ToGA() *ga.TargetPool { + if ret, ok := m.Obj.(*ga.TargetPool); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.TargetPool{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.TargetPool via JSON: %v", m.Obj, err) + } + return ret +} + +// MockUrlMapsObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockUrlMapsObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockUrlMapsObj) ToGA() *ga.UrlMap { + if ret, ok := m.Obj.(*ga.UrlMap); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.UrlMap{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.UrlMap via JSON: %v", m.Obj, err) + } + return ret +} + +// MockZonesObj is used to store the various object versions in the shared +// map of mocked objects. This allows for multiple API versions to co-exist and +// share the same "view" of the objects in the backend. +type MockZonesObj struct { + Obj interface{} +} + +// ToGA retrieves the given version of the object. +func (m *MockZonesObj) ToGA() *ga.Zone { + if ret, ok := m.Obj.(*ga.Zone); ok { + return ret + } + // Convert the object via JSON copying to the type that was requested. + ret := &ga.Zone{} + if err := copyViaJSON(ret, m.Obj); err != nil { + glog.Errorf("Could not convert %T to *ga.Zone via JSON: %v", m.Obj, err) + } + return ret +} + +// Addresses is an interface that allows for mocking of Addresses. +type Addresses interface { + Get(ctx context.Context, key meta.Key) (*ga.Address, error) + List(ctx context.Context, region string, fl *filter.F) ([]*ga.Address, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Address) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockAddresses returns a new mock for Addresses. +func NewMockAddresses(objs map[meta.Key]*MockAddressesObj) *MockAddresses { + mock := &MockAddresses{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAddresses is the mock for Addresses. +type MockAddresses struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockAddressesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAddresses, ctx context.Context, key meta.Key) (bool, *ga.Address, error) + ListHook func(m *MockAddresses, ctx context.Context, region string, fl *filter.F) (bool, []*ga.Address, error) + InsertHook func(m *MockAddresses, ctx context.Context, key meta.Key, obj *ga.Address) (bool, error) + DeleteHook func(m *MockAddresses, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAddresses) Get(ctx context.Context, key meta.Key) (*ga.Address, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAddresses.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockAddresses.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAddresses %v not found", key), + } + glog.V(5).Infof("MockAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Address, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockAddresses.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAddresses.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Address + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockAddresses.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAddresses) Insert(ctx context.Context, key meta.Key, obj *ga.Address) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAddresses %v exists", key), + } + glog.V(5).Infof("MockAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "addresses", key) + } + + m.Objects[key] = &MockAddressesObj{obj} + glog.V(5).Infof("MockAddresses.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAddresses) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAddresses %v not found", key), + } + glog.V(5).Infof("MockAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAddresses.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAddresses) Obj(o *ga.Address) *MockAddressesObj { + return &MockAddressesObj{o} +} + +// GCEAddresses is a simplifying adapter for the GCE Addresses. +type GCEAddresses struct { + s *Service +} + +// Get the Address named by key. +func (g *GCEAddresses) Get(ctx context.Context, key meta.Key) (*ga.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Addresses.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Address objects. +func (g *GCEAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Addresses.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Address + f := func(l *ga.AddressList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Address with key of value obj. +func (g *GCEAddresses) Insert(ctx context.Context, key meta.Key, obj *ga.Address) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.Addresses.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Address referenced by key. +func (g *GCEAddresses) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Addresses.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaAddresses is an interface that allows for mocking of Addresses. +type AlphaAddresses interface { + Get(ctx context.Context, key meta.Key) (*alpha.Address, error) + List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Address, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.Address) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockAlphaAddresses returns a new mock for Addresses. +func NewMockAlphaAddresses(objs map[meta.Key]*MockAddressesObj) *MockAlphaAddresses { + mock := &MockAlphaAddresses{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaAddresses is the mock for Addresses. +type MockAlphaAddresses struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockAddressesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaAddresses, ctx context.Context, key meta.Key) (bool, *alpha.Address, error) + ListHook func(m *MockAlphaAddresses, ctx context.Context, region string, fl *filter.F) (bool, []*alpha.Address, error) + InsertHook func(m *MockAlphaAddresses, ctx context.Context, key meta.Key, obj *alpha.Address) (bool, error) + DeleteHook func(m *MockAlphaAddresses, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaAddresses) Get(ctx context.Context, key meta.Key) (*alpha.Address, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaAddresses.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaAddresses.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaAddresses %v not found", key), + } + glog.V(5).Infof("MockAlphaAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockAlphaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Address, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockAlphaAddresses.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaAddresses.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.Address + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaAddresses.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaAddresses) Insert(ctx context.Context, key meta.Key, obj *alpha.Address) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaAddresses %v exists", key), + } + glog.V(5).Infof("MockAlphaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "addresses", key) + } + + m.Objects[key] = &MockAddressesObj{obj} + glog.V(5).Infof("MockAlphaAddresses.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaAddresses) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaAddresses %v not found", key), + } + glog.V(5).Infof("MockAlphaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaAddresses.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaAddresses) Obj(o *alpha.Address) *MockAddressesObj { + return &MockAddressesObj{o} +} + +// GCEAlphaAddresses is a simplifying adapter for the GCE Addresses. +type GCEAlphaAddresses struct { + s *Service +} + +// Get the Address named by key. +func (g *GCEAlphaAddresses) Get(ctx context.Context, key meta.Key) (*alpha.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Addresses.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Address objects. +func (g *GCEAlphaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Addresses.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.Address + f := func(l *alpha.AddressList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Address with key of value obj. +func (g *GCEAlphaAddresses) Insert(ctx context.Context, key meta.Key, obj *alpha.Address) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.Addresses.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Address referenced by key. +func (g *GCEAlphaAddresses) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Addresses.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// BetaAddresses is an interface that allows for mocking of Addresses. +type BetaAddresses interface { + Get(ctx context.Context, key meta.Key) (*beta.Address, error) + List(ctx context.Context, region string, fl *filter.F) ([]*beta.Address, error) + Insert(ctx context.Context, key meta.Key, obj *beta.Address) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockBetaAddresses returns a new mock for Addresses. +func NewMockBetaAddresses(objs map[meta.Key]*MockAddressesObj) *MockBetaAddresses { + mock := &MockBetaAddresses{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockBetaAddresses is the mock for Addresses. +type MockBetaAddresses struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockAddressesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockBetaAddresses, ctx context.Context, key meta.Key) (bool, *beta.Address, error) + ListHook func(m *MockBetaAddresses, ctx context.Context, region string, fl *filter.F) (bool, []*beta.Address, error) + InsertHook func(m *MockBetaAddresses, ctx context.Context, key meta.Key, obj *beta.Address) (bool, error) + DeleteHook func(m *MockBetaAddresses, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockBetaAddresses) Get(ctx context.Context, key meta.Key) (*beta.Address, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBetaAddresses.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockBetaAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToBeta() + glog.V(5).Infof("MockBetaAddresses.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaAddresses %v not found", key), + } + glog.V(5).Infof("MockBetaAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockBetaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Address, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockBetaAddresses.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockBetaAddresses.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*beta.Address + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToBeta()) { + continue + } + objs = append(objs, obj.ToBeta()) + } + + glog.V(5).Infof("MockBetaAddresses.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockBetaAddresses) Insert(ctx context.Context, key meta.Key, obj *beta.Address) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockBetaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockBetaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockBetaAddresses %v exists", key), + } + glog.V(5).Infof("MockBetaAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionBeta, "mock-project", "addresses", key) + } + + m.Objects[key] = &MockAddressesObj{obj} + glog.V(5).Infof("MockBetaAddresses.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockBetaAddresses) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBetaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockBetaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaAddresses %v not found", key), + } + glog.V(5).Infof("MockBetaAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockBetaAddresses.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockBetaAddresses) Obj(o *beta.Address) *MockAddressesObj { + return &MockAddressesObj{o} +} + +// GCEBetaAddresses is a simplifying adapter for the GCE Addresses. +type GCEBetaAddresses struct { + s *Service +} + +// Get the Address named by key. +func (g *GCEBetaAddresses) Get(ctx context.Context, key meta.Key) (*beta.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("beta"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Beta.Addresses.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Address objects. +func (g *GCEBetaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("beta"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Beta.Addresses.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*beta.Address + f := func(l *beta.AddressList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Address with key of value obj. +func (g *GCEBetaAddresses) Insert(ctx context.Context, key meta.Key, obj *beta.Address) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("beta"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Beta.Addresses.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Address referenced by key. +func (g *GCEBetaAddresses) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Addresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("beta"), + Service: "Addresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Beta.Addresses.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// GlobalAddresses is an interface that allows for mocking of GlobalAddresses. +type GlobalAddresses interface { + Get(ctx context.Context, key meta.Key) (*ga.Address, error) + List(ctx context.Context, fl *filter.F) ([]*ga.Address, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Address) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockGlobalAddresses returns a new mock for GlobalAddresses. +func NewMockGlobalAddresses(objs map[meta.Key]*MockGlobalAddressesObj) *MockGlobalAddresses { + mock := &MockGlobalAddresses{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockGlobalAddresses is the mock for GlobalAddresses. +type MockGlobalAddresses struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockGlobalAddressesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockGlobalAddresses, ctx context.Context, key meta.Key) (bool, *ga.Address, error) + ListHook func(m *MockGlobalAddresses, ctx context.Context, fl *filter.F) (bool, []*ga.Address, error) + InsertHook func(m *MockGlobalAddresses, ctx context.Context, key meta.Key, obj *ga.Address) (bool, error) + DeleteHook func(m *MockGlobalAddresses, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockGlobalAddresses) Get(ctx context.Context, key meta.Key) (*ga.Address, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockGlobalAddresses.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockGlobalAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockGlobalAddresses.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockGlobalAddresses %v not found", key), + } + glog.V(5).Infof("MockGlobalAddresses.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockGlobalAddresses) List(ctx context.Context, fl *filter.F) ([]*ga.Address, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockGlobalAddresses.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockGlobalAddresses.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Address + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockGlobalAddresses.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockGlobalAddresses) Insert(ctx context.Context, key meta.Key, obj *ga.Address) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockGlobalAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockGlobalAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockGlobalAddresses %v exists", key), + } + glog.V(5).Infof("MockGlobalAddresses.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "addresses", key) + } + + m.Objects[key] = &MockGlobalAddressesObj{obj} + glog.V(5).Infof("MockGlobalAddresses.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockGlobalAddresses) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockGlobalAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockGlobalAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockGlobalAddresses %v not found", key), + } + glog.V(5).Infof("MockGlobalAddresses.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockGlobalAddresses.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockGlobalAddresses) Obj(o *ga.Address) *MockGlobalAddressesObj { + return &MockGlobalAddressesObj{o} +} + +// GCEGlobalAddresses is a simplifying adapter for the GCE GlobalAddresses. +type GCEGlobalAddresses struct { + s *Service +} + +// Get the Address named by key. +func (g *GCEGlobalAddresses) Get(ctx context.Context, key meta.Key) (*ga.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalAddresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "GlobalAddresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.GlobalAddresses.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Address objects. +func (g *GCEGlobalAddresses) List(ctx context.Context, fl *filter.F) ([]*ga.Address, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalAddresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "GlobalAddresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.GlobalAddresses.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Address + f := func(l *ga.AddressList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Address with key of value obj. +func (g *GCEGlobalAddresses) Insert(ctx context.Context, key meta.Key, obj *ga.Address) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalAddresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "GlobalAddresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.GlobalAddresses.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Address referenced by key. +func (g *GCEGlobalAddresses) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalAddresses") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "GlobalAddresses", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.GlobalAddresses.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// BackendServices is an interface that allows for mocking of BackendServices. +type BackendServices interface { + Get(ctx context.Context, key meta.Key) (*ga.BackendService, error) + List(ctx context.Context, fl *filter.F) ([]*ga.BackendService, error) + Insert(ctx context.Context, key meta.Key, obj *ga.BackendService) error + Delete(ctx context.Context, key meta.Key) error + GetHealth(context.Context, meta.Key, *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error) + Update(context.Context, meta.Key, *ga.BackendService) error +} + +// NewMockBackendServices returns a new mock for BackendServices. +func NewMockBackendServices(objs map[meta.Key]*MockBackendServicesObj) *MockBackendServices { + mock := &MockBackendServices{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockBackendServices is the mock for BackendServices. +type MockBackendServices struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockBackendServicesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockBackendServices, ctx context.Context, key meta.Key) (bool, *ga.BackendService, error) + ListHook func(m *MockBackendServices, ctx context.Context, fl *filter.F) (bool, []*ga.BackendService, error) + InsertHook func(m *MockBackendServices, ctx context.Context, key meta.Key, obj *ga.BackendService) (bool, error) + DeleteHook func(m *MockBackendServices, ctx context.Context, key meta.Key) (bool, error) + GetHealthHook func(*MockBackendServices, context.Context, meta.Key, *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error) + UpdateHook func(*MockBackendServices, context.Context, meta.Key, *ga.BackendService) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockBackendServices) Get(ctx context.Context, key meta.Key) (*ga.BackendService, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBackendServices.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockBackendServices.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBackendServices %v not found", key), + } + glog.V(5).Infof("MockBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockBackendServices) List(ctx context.Context, fl *filter.F) ([]*ga.BackendService, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockBackendServices.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockBackendServices.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.BackendService + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockBackendServices.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockBackendServices) Insert(ctx context.Context, key meta.Key, obj *ga.BackendService) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockBackendServices %v exists", key), + } + glog.V(5).Infof("MockBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "backendServices", key) + } + + m.Objects[key] = &MockBackendServicesObj{obj} + glog.V(5).Infof("MockBackendServices.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockBackendServices) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBackendServices %v not found", key), + } + glog.V(5).Infof("MockBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockBackendServices.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockBackendServices) Obj(o *ga.BackendService) *MockBackendServicesObj { + return &MockBackendServicesObj{o} +} + +// GetHealth is a mock for the corresponding method. +func (m *MockBackendServices) GetHealth(ctx context.Context, key meta.Key, arg0 *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error) { + if m.GetHealthHook != nil { + return m.GetHealthHook(m, ctx, key, arg0) + } + return nil, fmt.Errorf("GetHealthHook must be set") +} + +// Update is a mock for the corresponding method. +func (m *MockBackendServices) Update(ctx context.Context, key meta.Key, arg0 *ga.BackendService) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEBackendServices is a simplifying adapter for the GCE BackendServices. +type GCEBackendServices struct { + s *Service +} + +// Get the BackendService named by key. +func (g *GCEBackendServices) Get(ctx context.Context, key meta.Key) (*ga.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.BackendServices.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all BackendService objects. +func (g *GCEBackendServices) List(ctx context.Context, fl *filter.F) ([]*ga.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.BackendServices.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.BackendService + f := func(l *ga.BackendServiceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert BackendService with key of value obj. +func (g *GCEBackendServices) Insert(ctx context.Context, key meta.Key, obj *ga.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.BackendServices.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the BackendService referenced by key. +func (g *GCEBackendServices) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.BackendServices.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// GetHealth is a method on GCEBackendServices. +func (g *GCEBackendServices) GetHealth(ctx context.Context, key meta.Key, arg0 *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "GetHealth", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.BackendServices.GetHealth(projectID, key.Name, arg0) + call.Context(ctx) + return call.Do() +} + +// Update is a method on GCEBackendServices. +func (g *GCEBackendServices) Update(ctx context.Context, key meta.Key, arg0 *ga.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.BackendServices.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaBackendServices is an interface that allows for mocking of BackendServices. +type AlphaBackendServices interface { + Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) + List(ctx context.Context, fl *filter.F) ([]*alpha.BackendService, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *alpha.BackendService) error +} + +// NewMockAlphaBackendServices returns a new mock for BackendServices. +func NewMockAlphaBackendServices(objs map[meta.Key]*MockBackendServicesObj) *MockAlphaBackendServices { + mock := &MockAlphaBackendServices{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaBackendServices is the mock for BackendServices. +type MockAlphaBackendServices struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockBackendServicesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaBackendServices, ctx context.Context, key meta.Key) (bool, *alpha.BackendService, error) + ListHook func(m *MockAlphaBackendServices, ctx context.Context, fl *filter.F) (bool, []*alpha.BackendService, error) + InsertHook func(m *MockAlphaBackendServices, ctx context.Context, key meta.Key, obj *alpha.BackendService) (bool, error) + DeleteHook func(m *MockAlphaBackendServices, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockAlphaBackendServices, context.Context, meta.Key, *alpha.BackendService) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaBackendServices) Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaBackendServices.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaBackendServices.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaBackendServices %v not found", key), + } + glog.V(5).Infof("MockAlphaBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockAlphaBackendServices) List(ctx context.Context, fl *filter.F) ([]*alpha.BackendService, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockAlphaBackendServices.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaBackendServices.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.BackendService + for _, obj := range m.Objects { + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaBackendServices.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaBackendServices) Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaBackendServices %v exists", key), + } + glog.V(5).Infof("MockAlphaBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "backendServices", key) + } + + m.Objects[key] = &MockBackendServicesObj{obj} + glog.V(5).Infof("MockAlphaBackendServices.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaBackendServices) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaBackendServices %v not found", key), + } + glog.V(5).Infof("MockAlphaBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaBackendServices.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaBackendServices) Obj(o *alpha.BackendService) *MockBackendServicesObj { + return &MockBackendServicesObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockAlphaBackendServices) Update(ctx context.Context, key meta.Key, arg0 *alpha.BackendService) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEAlphaBackendServices is a simplifying adapter for the GCE BackendServices. +type GCEAlphaBackendServices struct { + s *Service +} + +// Get the BackendService named by key. +func (g *GCEAlphaBackendServices) Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.BackendServices.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all BackendService objects. +func (g *GCEAlphaBackendServices) List(ctx context.Context, fl *filter.F) ([]*alpha.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.BackendServices.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.BackendService + f := func(l *alpha.BackendServiceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert BackendService with key of value obj. +func (g *GCEAlphaBackendServices) Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.BackendServices.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the BackendService referenced by key. +func (g *GCEAlphaBackendServices) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.BackendServices.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEAlphaBackendServices. +func (g *GCEAlphaBackendServices) Update(ctx context.Context, key meta.Key, arg0 *alpha.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "BackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("alpha"), + Service: "BackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.BackendServices.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaRegionBackendServices is an interface that allows for mocking of RegionBackendServices. +type AlphaRegionBackendServices interface { + Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) + List(ctx context.Context, region string, fl *filter.F) ([]*alpha.BackendService, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error + Delete(ctx context.Context, key meta.Key) error + GetHealth(context.Context, meta.Key, *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error) + Update(context.Context, meta.Key, *alpha.BackendService) error +} + +// NewMockAlphaRegionBackendServices returns a new mock for RegionBackendServices. +func NewMockAlphaRegionBackendServices(objs map[meta.Key]*MockRegionBackendServicesObj) *MockAlphaRegionBackendServices { + mock := &MockAlphaRegionBackendServices{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaRegionBackendServices is the mock for RegionBackendServices. +type MockAlphaRegionBackendServices struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRegionBackendServicesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaRegionBackendServices, ctx context.Context, key meta.Key) (bool, *alpha.BackendService, error) + ListHook func(m *MockAlphaRegionBackendServices, ctx context.Context, region string, fl *filter.F) (bool, []*alpha.BackendService, error) + InsertHook func(m *MockAlphaRegionBackendServices, ctx context.Context, key meta.Key, obj *alpha.BackendService) (bool, error) + DeleteHook func(m *MockAlphaRegionBackendServices, ctx context.Context, key meta.Key) (bool, error) + GetHealthHook func(*MockAlphaRegionBackendServices, context.Context, meta.Key, *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error) + UpdateHook func(*MockAlphaRegionBackendServices, context.Context, meta.Key, *alpha.BackendService) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaRegionBackendServices) Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaRegionBackendServices.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaRegionBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaRegionBackendServices.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRegionBackendServices %v not found", key), + } + glog.V(5).Infof("MockAlphaRegionBackendServices.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockAlphaRegionBackendServices) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.BackendService, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockAlphaRegionBackendServices.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaRegionBackendServices.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.BackendService + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaRegionBackendServices.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaRegionBackendServices) Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaRegionBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaRegionBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaRegionBackendServices %v exists", key), + } + glog.V(5).Infof("MockAlphaRegionBackendServices.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "backendServices", key) + } + + m.Objects[key] = &MockRegionBackendServicesObj{obj} + glog.V(5).Infof("MockAlphaRegionBackendServices.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaRegionBackendServices) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaRegionBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaRegionBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRegionBackendServices %v not found", key), + } + glog.V(5).Infof("MockAlphaRegionBackendServices.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaRegionBackendServices.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaRegionBackendServices) Obj(o *alpha.BackendService) *MockRegionBackendServicesObj { + return &MockRegionBackendServicesObj{o} +} + +// GetHealth is a mock for the corresponding method. +func (m *MockAlphaRegionBackendServices) GetHealth(ctx context.Context, key meta.Key, arg0 *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error) { + if m.GetHealthHook != nil { + return m.GetHealthHook(m, ctx, key, arg0) + } + return nil, fmt.Errorf("GetHealthHook must be set") +} + +// Update is a mock for the corresponding method. +func (m *MockAlphaRegionBackendServices) Update(ctx context.Context, key meta.Key, arg0 *alpha.BackendService) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEAlphaRegionBackendServices is a simplifying adapter for the GCE RegionBackendServices. +type GCEAlphaRegionBackendServices struct { + s *Service +} + +// Get the BackendService named by key. +func (g *GCEAlphaRegionBackendServices) Get(ctx context.Context, key meta.Key) (*alpha.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.RegionBackendServices.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all BackendService objects. +func (g *GCEAlphaRegionBackendServices) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.BackendService, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.RegionBackendServices.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.BackendService + f := func(l *alpha.BackendServiceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert BackendService with key of value obj. +func (g *GCEAlphaRegionBackendServices) Insert(ctx context.Context, key meta.Key, obj *alpha.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.RegionBackendServices.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the BackendService referenced by key. +func (g *GCEAlphaRegionBackendServices) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.RegionBackendServices.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// GetHealth is a method on GCEAlphaRegionBackendServices. +func (g *GCEAlphaRegionBackendServices) GetHealth(ctx context.Context, key meta.Key, arg0 *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "GetHealth", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.RegionBackendServices.GetHealth(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + return call.Do() +} + +// Update is a method on GCEAlphaRegionBackendServices. +func (g *GCEAlphaRegionBackendServices) Update(ctx context.Context, key meta.Key, arg0 *alpha.BackendService) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionBackendServices") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("alpha"), + Service: "RegionBackendServices", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.RegionBackendServices.Update(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Disks is an interface that allows for mocking of Disks. +type Disks interface { + Get(ctx context.Context, key meta.Key) (*ga.Disk, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Disk, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Disk) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockDisks returns a new mock for Disks. +func NewMockDisks(objs map[meta.Key]*MockDisksObj) *MockDisks { + mock := &MockDisks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockDisks is the mock for Disks. +type MockDisks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockDisksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockDisks, ctx context.Context, key meta.Key) (bool, *ga.Disk, error) + ListHook func(m *MockDisks, ctx context.Context, zone string, fl *filter.F) (bool, []*ga.Disk, error) + InsertHook func(m *MockDisks, ctx context.Context, key meta.Key, obj *ga.Disk) (bool, error) + DeleteHook func(m *MockDisks, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockDisks) Get(ctx context.Context, key meta.Key) (*ga.Disk, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockDisks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockDisks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockDisks %v not found", key), + } + glog.V(5).Infof("MockDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockDisks) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Disk, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockDisks.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockDisks.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Disk + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockDisks.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockDisks) Insert(ctx context.Context, key meta.Key, obj *ga.Disk) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockDisks %v exists", key), + } + glog.V(5).Infof("MockDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "disks", key) + } + + m.Objects[key] = &MockDisksObj{obj} + glog.V(5).Infof("MockDisks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockDisks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockDisks %v not found", key), + } + glog.V(5).Infof("MockDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockDisks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockDisks) Obj(o *ga.Disk) *MockDisksObj { + return &MockDisksObj{o} +} + +// GCEDisks is a simplifying adapter for the GCE Disks. +type GCEDisks struct { + s *Service +} + +// Get the Disk named by key. +func (g *GCEDisks) Get(ctx context.Context, key meta.Key) (*ga.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Disks.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Disk objects. +func (g *GCEDisks) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Disks.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Disk + f := func(l *ga.DiskList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Disk with key of value obj. +func (g *GCEDisks) Insert(ctx context.Context, key meta.Key, obj *ga.Disk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.Disks.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Disk referenced by key. +func (g *GCEDisks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Disks.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaDisks is an interface that allows for mocking of Disks. +type AlphaDisks interface { + Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Disk, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockAlphaDisks returns a new mock for Disks. +func NewMockAlphaDisks(objs map[meta.Key]*MockDisksObj) *MockAlphaDisks { + mock := &MockAlphaDisks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaDisks is the mock for Disks. +type MockAlphaDisks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockDisksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaDisks, ctx context.Context, key meta.Key) (bool, *alpha.Disk, error) + ListHook func(m *MockAlphaDisks, ctx context.Context, zone string, fl *filter.F) (bool, []*alpha.Disk, error) + InsertHook func(m *MockAlphaDisks, ctx context.Context, key meta.Key, obj *alpha.Disk) (bool, error) + DeleteHook func(m *MockAlphaDisks, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaDisks) Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaDisks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaDisks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaDisks %v not found", key), + } + glog.V(5).Infof("MockAlphaDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockAlphaDisks) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Disk, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockAlphaDisks.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaDisks.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.Disk + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaDisks.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaDisks) Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaDisks %v exists", key), + } + glog.V(5).Infof("MockAlphaDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "disks", key) + } + + m.Objects[key] = &MockDisksObj{obj} + glog.V(5).Infof("MockAlphaDisks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaDisks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaDisks %v not found", key), + } + glog.V(5).Infof("MockAlphaDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaDisks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaDisks) Obj(o *alpha.Disk) *MockDisksObj { + return &MockDisksObj{o} +} + +// GCEAlphaDisks is a simplifying adapter for the GCE Disks. +type GCEAlphaDisks struct { + s *Service +} + +// Get the Disk named by key. +func (g *GCEAlphaDisks) Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Disks.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Disk objects. +func (g *GCEAlphaDisks) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Disks.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.Disk + f := func(l *alpha.DiskList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Disk with key of value obj. +func (g *GCEAlphaDisks) Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.Disks.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Disk referenced by key. +func (g *GCEAlphaDisks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Disks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "Disks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Disks.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaRegionDisks is an interface that allows for mocking of RegionDisks. +type AlphaRegionDisks interface { + Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) + List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Disk, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockAlphaRegionDisks returns a new mock for RegionDisks. +func NewMockAlphaRegionDisks(objs map[meta.Key]*MockRegionDisksObj) *MockAlphaRegionDisks { + mock := &MockAlphaRegionDisks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaRegionDisks is the mock for RegionDisks. +type MockAlphaRegionDisks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRegionDisksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaRegionDisks, ctx context.Context, key meta.Key) (bool, *alpha.Disk, error) + ListHook func(m *MockAlphaRegionDisks, ctx context.Context, region string, fl *filter.F) (bool, []*alpha.Disk, error) + InsertHook func(m *MockAlphaRegionDisks, ctx context.Context, key meta.Key, obj *alpha.Disk) (bool, error) + DeleteHook func(m *MockAlphaRegionDisks, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaRegionDisks) Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaRegionDisks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaRegionDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaRegionDisks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRegionDisks %v not found", key), + } + glog.V(5).Infof("MockAlphaRegionDisks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockAlphaRegionDisks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Disk, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockAlphaRegionDisks.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaRegionDisks.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.Disk + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaRegionDisks.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaRegionDisks) Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaRegionDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaRegionDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaRegionDisks %v exists", key), + } + glog.V(5).Infof("MockAlphaRegionDisks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "disks", key) + } + + m.Objects[key] = &MockRegionDisksObj{obj} + glog.V(5).Infof("MockAlphaRegionDisks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaRegionDisks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaRegionDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaRegionDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaRegionDisks %v not found", key), + } + glog.V(5).Infof("MockAlphaRegionDisks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaRegionDisks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaRegionDisks) Obj(o *alpha.Disk) *MockRegionDisksObj { + return &MockRegionDisksObj{o} +} + +// GCEAlphaRegionDisks is a simplifying adapter for the GCE RegionDisks. +type GCEAlphaRegionDisks struct { + s *Service +} + +// Get the Disk named by key. +func (g *GCEAlphaRegionDisks) Get(ctx context.Context, key meta.Key) (*alpha.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionDisks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "RegionDisks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.RegionDisks.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Disk objects. +func (g *GCEAlphaRegionDisks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Disk, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionDisks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "RegionDisks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.RegionDisks.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.Disk + f := func(l *alpha.DiskList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Disk with key of value obj. +func (g *GCEAlphaRegionDisks) Insert(ctx context.Context, key meta.Key, obj *alpha.Disk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionDisks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "RegionDisks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.RegionDisks.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Disk referenced by key. +func (g *GCEAlphaRegionDisks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "RegionDisks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "RegionDisks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.RegionDisks.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Firewalls is an interface that allows for mocking of Firewalls. +type Firewalls interface { + Get(ctx context.Context, key meta.Key) (*ga.Firewall, error) + List(ctx context.Context, fl *filter.F) ([]*ga.Firewall, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Firewall) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *ga.Firewall) error +} + +// NewMockFirewalls returns a new mock for Firewalls. +func NewMockFirewalls(objs map[meta.Key]*MockFirewallsObj) *MockFirewalls { + mock := &MockFirewalls{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockFirewalls is the mock for Firewalls. +type MockFirewalls struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockFirewallsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockFirewalls, ctx context.Context, key meta.Key) (bool, *ga.Firewall, error) + ListHook func(m *MockFirewalls, ctx context.Context, fl *filter.F) (bool, []*ga.Firewall, error) + InsertHook func(m *MockFirewalls, ctx context.Context, key meta.Key, obj *ga.Firewall) (bool, error) + DeleteHook func(m *MockFirewalls, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockFirewalls, context.Context, meta.Key, *ga.Firewall) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockFirewalls) Get(ctx context.Context, key meta.Key) (*ga.Firewall, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockFirewalls.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockFirewalls.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockFirewalls.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockFirewalls %v not found", key), + } + glog.V(5).Infof("MockFirewalls.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockFirewalls) List(ctx context.Context, fl *filter.F) ([]*ga.Firewall, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockFirewalls.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockFirewalls.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Firewall + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockFirewalls.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockFirewalls) Insert(ctx context.Context, key meta.Key, obj *ga.Firewall) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockFirewalls.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockFirewalls.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockFirewalls %v exists", key), + } + glog.V(5).Infof("MockFirewalls.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "firewalls", key) + } + + m.Objects[key] = &MockFirewallsObj{obj} + glog.V(5).Infof("MockFirewalls.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockFirewalls) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockFirewalls.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockFirewalls.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockFirewalls %v not found", key), + } + glog.V(5).Infof("MockFirewalls.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockFirewalls.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockFirewalls) Obj(o *ga.Firewall) *MockFirewallsObj { + return &MockFirewallsObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockFirewalls) Update(ctx context.Context, key meta.Key, arg0 *ga.Firewall) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEFirewalls is a simplifying adapter for the GCE Firewalls. +type GCEFirewalls struct { + s *Service +} + +// Get the Firewall named by key. +func (g *GCEFirewalls) Get(ctx context.Context, key meta.Key) (*ga.Firewall, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Firewalls") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Firewalls", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Firewalls.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Firewall objects. +func (g *GCEFirewalls) List(ctx context.Context, fl *filter.F) ([]*ga.Firewall, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Firewalls") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Firewalls", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Firewalls.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Firewall + f := func(l *ga.FirewallList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Firewall with key of value obj. +func (g *GCEFirewalls) Insert(ctx context.Context, key meta.Key, obj *ga.Firewall) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Firewalls") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "Firewalls", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.Firewalls.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Firewall referenced by key. +func (g *GCEFirewalls) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Firewalls") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "Firewalls", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Firewalls.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEFirewalls. +func (g *GCEFirewalls) Update(ctx context.Context, key meta.Key, arg0 *ga.Firewall) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Firewalls") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "Firewalls", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Firewalls.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// ForwardingRules is an interface that allows for mocking of ForwardingRules. +type ForwardingRules interface { + Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) + List(ctx context.Context, region string, fl *filter.F) ([]*ga.ForwardingRule, error) + Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockForwardingRules returns a new mock for ForwardingRules. +func NewMockForwardingRules(objs map[meta.Key]*MockForwardingRulesObj) *MockForwardingRules { + mock := &MockForwardingRules{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockForwardingRules is the mock for ForwardingRules. +type MockForwardingRules struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockForwardingRulesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockForwardingRules, ctx context.Context, key meta.Key) (bool, *ga.ForwardingRule, error) + ListHook func(m *MockForwardingRules, ctx context.Context, region string, fl *filter.F) (bool, []*ga.ForwardingRule, error) + InsertHook func(m *MockForwardingRules, ctx context.Context, key meta.Key, obj *ga.ForwardingRule) (bool, error) + DeleteHook func(m *MockForwardingRules, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockForwardingRules) Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockForwardingRules.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockForwardingRules.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockForwardingRules %v not found", key), + } + glog.V(5).Infof("MockForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*ga.ForwardingRule, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockForwardingRules.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockForwardingRules.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.ForwardingRule + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockForwardingRules.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockForwardingRules) Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockForwardingRules %v exists", key), + } + glog.V(5).Infof("MockForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "forwardingRules", key) + } + + m.Objects[key] = &MockForwardingRulesObj{obj} + glog.V(5).Infof("MockForwardingRules.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockForwardingRules) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockForwardingRules %v not found", key), + } + glog.V(5).Infof("MockForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockForwardingRules.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockForwardingRules) Obj(o *ga.ForwardingRule) *MockForwardingRulesObj { + return &MockForwardingRulesObj{o} +} + +// GCEForwardingRules is a simplifying adapter for the GCE ForwardingRules. +type GCEForwardingRules struct { + s *Service +} + +// Get the ForwardingRule named by key. +func (g *GCEForwardingRules) Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.ForwardingRules.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all ForwardingRule objects. +func (g *GCEForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*ga.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.ForwardingRules.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.ForwardingRule + f := func(l *ga.ForwardingRuleList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert ForwardingRule with key of value obj. +func (g *GCEForwardingRules) Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.ForwardingRules.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the ForwardingRule referenced by key. +func (g *GCEForwardingRules) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.ForwardingRules.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaForwardingRules is an interface that allows for mocking of ForwardingRules. +type AlphaForwardingRules interface { + Get(ctx context.Context, key meta.Key) (*alpha.ForwardingRule, error) + List(ctx context.Context, region string, fl *filter.F) ([]*alpha.ForwardingRule, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.ForwardingRule) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockAlphaForwardingRules returns a new mock for ForwardingRules. +func NewMockAlphaForwardingRules(objs map[meta.Key]*MockForwardingRulesObj) *MockAlphaForwardingRules { + mock := &MockAlphaForwardingRules{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaForwardingRules is the mock for ForwardingRules. +type MockAlphaForwardingRules struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockForwardingRulesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaForwardingRules, ctx context.Context, key meta.Key) (bool, *alpha.ForwardingRule, error) + ListHook func(m *MockAlphaForwardingRules, ctx context.Context, region string, fl *filter.F) (bool, []*alpha.ForwardingRule, error) + InsertHook func(m *MockAlphaForwardingRules, ctx context.Context, key meta.Key, obj *alpha.ForwardingRule) (bool, error) + DeleteHook func(m *MockAlphaForwardingRules, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaForwardingRules) Get(ctx context.Context, key meta.Key) (*alpha.ForwardingRule, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaForwardingRules.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaForwardingRules.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaForwardingRules %v not found", key), + } + glog.V(5).Infof("MockAlphaForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockAlphaForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.ForwardingRule, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockAlphaForwardingRules.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaForwardingRules.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.ForwardingRule + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaForwardingRules.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaForwardingRules) Insert(ctx context.Context, key meta.Key, obj *alpha.ForwardingRule) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaForwardingRules %v exists", key), + } + glog.V(5).Infof("MockAlphaForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "forwardingRules", key) + } + + m.Objects[key] = &MockForwardingRulesObj{obj} + glog.V(5).Infof("MockAlphaForwardingRules.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaForwardingRules) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaForwardingRules %v not found", key), + } + glog.V(5).Infof("MockAlphaForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaForwardingRules.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaForwardingRules) Obj(o *alpha.ForwardingRule) *MockForwardingRulesObj { + return &MockForwardingRulesObj{o} +} + +// GCEAlphaForwardingRules is a simplifying adapter for the GCE ForwardingRules. +type GCEAlphaForwardingRules struct { + s *Service +} + +// Get the ForwardingRule named by key. +func (g *GCEAlphaForwardingRules) Get(ctx context.Context, key meta.Key) (*alpha.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.ForwardingRules.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all ForwardingRule objects. +func (g *GCEAlphaForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.ForwardingRules.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.ForwardingRule + f := func(l *alpha.ForwardingRuleList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert ForwardingRule with key of value obj. +func (g *GCEAlphaForwardingRules) Insert(ctx context.Context, key meta.Key, obj *alpha.ForwardingRule) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.ForwardingRules.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the ForwardingRule referenced by key. +func (g *GCEAlphaForwardingRules) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "ForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "ForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.ForwardingRules.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// GlobalForwardingRules is an interface that allows for mocking of GlobalForwardingRules. +type GlobalForwardingRules interface { + Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) + List(ctx context.Context, fl *filter.F) ([]*ga.ForwardingRule, error) + Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error + Delete(ctx context.Context, key meta.Key) error + SetTarget(context.Context, meta.Key, *ga.TargetReference) error +} + +// NewMockGlobalForwardingRules returns a new mock for GlobalForwardingRules. +func NewMockGlobalForwardingRules(objs map[meta.Key]*MockGlobalForwardingRulesObj) *MockGlobalForwardingRules { + mock := &MockGlobalForwardingRules{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockGlobalForwardingRules is the mock for GlobalForwardingRules. +type MockGlobalForwardingRules struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockGlobalForwardingRulesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockGlobalForwardingRules, ctx context.Context, key meta.Key) (bool, *ga.ForwardingRule, error) + ListHook func(m *MockGlobalForwardingRules, ctx context.Context, fl *filter.F) (bool, []*ga.ForwardingRule, error) + InsertHook func(m *MockGlobalForwardingRules, ctx context.Context, key meta.Key, obj *ga.ForwardingRule) (bool, error) + DeleteHook func(m *MockGlobalForwardingRules, ctx context.Context, key meta.Key) (bool, error) + SetTargetHook func(*MockGlobalForwardingRules, context.Context, meta.Key, *ga.TargetReference) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockGlobalForwardingRules) Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockGlobalForwardingRules.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockGlobalForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockGlobalForwardingRules.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockGlobalForwardingRules %v not found", key), + } + glog.V(5).Infof("MockGlobalForwardingRules.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockGlobalForwardingRules) List(ctx context.Context, fl *filter.F) ([]*ga.ForwardingRule, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockGlobalForwardingRules.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockGlobalForwardingRules.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.ForwardingRule + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockGlobalForwardingRules.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockGlobalForwardingRules) Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockGlobalForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockGlobalForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockGlobalForwardingRules %v exists", key), + } + glog.V(5).Infof("MockGlobalForwardingRules.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "forwardingRules", key) + } + + m.Objects[key] = &MockGlobalForwardingRulesObj{obj} + glog.V(5).Infof("MockGlobalForwardingRules.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockGlobalForwardingRules) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockGlobalForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockGlobalForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockGlobalForwardingRules %v not found", key), + } + glog.V(5).Infof("MockGlobalForwardingRules.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockGlobalForwardingRules.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockGlobalForwardingRules) Obj(o *ga.ForwardingRule) *MockGlobalForwardingRulesObj { + return &MockGlobalForwardingRulesObj{o} +} + +// SetTarget is a mock for the corresponding method. +func (m *MockGlobalForwardingRules) SetTarget(ctx context.Context, key meta.Key, arg0 *ga.TargetReference) error { + if m.SetTargetHook != nil { + return m.SetTargetHook(m, ctx, key, arg0) + } + return nil +} + +// GCEGlobalForwardingRules is a simplifying adapter for the GCE GlobalForwardingRules. +type GCEGlobalForwardingRules struct { + s *Service +} + +// Get the ForwardingRule named by key. +func (g *GCEGlobalForwardingRules) Get(ctx context.Context, key meta.Key) (*ga.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "GlobalForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.GlobalForwardingRules.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all ForwardingRule objects. +func (g *GCEGlobalForwardingRules) List(ctx context.Context, fl *filter.F) ([]*ga.ForwardingRule, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "GlobalForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.GlobalForwardingRules.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.ForwardingRule + f := func(l *ga.ForwardingRuleList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert ForwardingRule with key of value obj. +func (g *GCEGlobalForwardingRules) Insert(ctx context.Context, key meta.Key, obj *ga.ForwardingRule) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "GlobalForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.GlobalForwardingRules.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the ForwardingRule referenced by key. +func (g *GCEGlobalForwardingRules) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "GlobalForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.GlobalForwardingRules.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SetTarget is a method on GCEGlobalForwardingRules. +func (g *GCEGlobalForwardingRules) SetTarget(ctx context.Context, key meta.Key, arg0 *ga.TargetReference) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "GlobalForwardingRules") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetTarget", + Version: meta.Version("ga"), + Service: "GlobalForwardingRules", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.GlobalForwardingRules.SetTarget(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// HealthChecks is an interface that allows for mocking of HealthChecks. +type HealthChecks interface { + Get(ctx context.Context, key meta.Key) (*ga.HealthCheck, error) + List(ctx context.Context, fl *filter.F) ([]*ga.HealthCheck, error) + Insert(ctx context.Context, key meta.Key, obj *ga.HealthCheck) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *ga.HealthCheck) error +} + +// NewMockHealthChecks returns a new mock for HealthChecks. +func NewMockHealthChecks(objs map[meta.Key]*MockHealthChecksObj) *MockHealthChecks { + mock := &MockHealthChecks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockHealthChecks is the mock for HealthChecks. +type MockHealthChecks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockHealthChecksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockHealthChecks, ctx context.Context, key meta.Key) (bool, *ga.HealthCheck, error) + ListHook func(m *MockHealthChecks, ctx context.Context, fl *filter.F) (bool, []*ga.HealthCheck, error) + InsertHook func(m *MockHealthChecks, ctx context.Context, key meta.Key, obj *ga.HealthCheck) (bool, error) + DeleteHook func(m *MockHealthChecks, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockHealthChecks, context.Context, meta.Key, *ga.HealthCheck) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HealthCheck, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHealthChecks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockHealthChecks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HealthCheck, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockHealthChecks.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockHealthChecks.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.HealthCheck + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockHealthChecks.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HealthCheck) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockHealthChecks %v exists", key), + } + glog.V(5).Infof("MockHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "healthChecks", key) + } + + m.Objects[key] = &MockHealthChecksObj{obj} + glog.V(5).Infof("MockHealthChecks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockHealthChecks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockHealthChecks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockHealthChecks) Obj(o *ga.HealthCheck) *MockHealthChecksObj { + return &MockHealthChecksObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HealthCheck) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEHealthChecks is a simplifying adapter for the GCE HealthChecks. +type GCEHealthChecks struct { + s *Service +} + +// Get the HealthCheck named by key. +func (g *GCEHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HealthChecks.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all HealthCheck objects. +func (g *GCEHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HealthChecks.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.HealthCheck + f := func(l *ga.HealthCheckList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert HealthCheck with key of value obj. +func (g *GCEHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.HealthChecks.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the HealthCheck referenced by key. +func (g *GCEHealthChecks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HealthChecks.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEHealthChecks. +func (g *GCEHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HealthChecks.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaHealthChecks is an interface that allows for mocking of HealthChecks. +type AlphaHealthChecks interface { + Get(ctx context.Context, key meta.Key) (*alpha.HealthCheck, error) + List(ctx context.Context, fl *filter.F) ([]*alpha.HealthCheck, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.HealthCheck) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *alpha.HealthCheck) error +} + +// NewMockAlphaHealthChecks returns a new mock for HealthChecks. +func NewMockAlphaHealthChecks(objs map[meta.Key]*MockHealthChecksObj) *MockAlphaHealthChecks { + mock := &MockAlphaHealthChecks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaHealthChecks is the mock for HealthChecks. +type MockAlphaHealthChecks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockHealthChecksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaHealthChecks, ctx context.Context, key meta.Key) (bool, *alpha.HealthCheck, error) + ListHook func(m *MockAlphaHealthChecks, ctx context.Context, fl *filter.F) (bool, []*alpha.HealthCheck, error) + InsertHook func(m *MockAlphaHealthChecks, ctx context.Context, key meta.Key, obj *alpha.HealthCheck) (bool, error) + DeleteHook func(m *MockAlphaHealthChecks, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockAlphaHealthChecks, context.Context, meta.Key, *alpha.HealthCheck) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaHealthChecks) Get(ctx context.Context, key meta.Key) (*alpha.HealthCheck, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaHealthChecks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaHealthChecks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaHealthChecks %v not found", key), + } + glog.V(5).Infof("MockAlphaHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockAlphaHealthChecks) List(ctx context.Context, fl *filter.F) ([]*alpha.HealthCheck, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockAlphaHealthChecks.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaHealthChecks.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.HealthCheck + for _, obj := range m.Objects { + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaHealthChecks.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaHealthChecks) Insert(ctx context.Context, key meta.Key, obj *alpha.HealthCheck) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaHealthChecks %v exists", key), + } + glog.V(5).Infof("MockAlphaHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "healthChecks", key) + } + + m.Objects[key] = &MockHealthChecksObj{obj} + glog.V(5).Infof("MockAlphaHealthChecks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaHealthChecks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaHealthChecks %v not found", key), + } + glog.V(5).Infof("MockAlphaHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaHealthChecks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaHealthChecks) Obj(o *alpha.HealthCheck) *MockHealthChecksObj { + return &MockHealthChecksObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockAlphaHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *alpha.HealthCheck) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEAlphaHealthChecks is a simplifying adapter for the GCE HealthChecks. +type GCEAlphaHealthChecks struct { + s *Service +} + +// Get the HealthCheck named by key. +func (g *GCEAlphaHealthChecks) Get(ctx context.Context, key meta.Key) (*alpha.HealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.HealthChecks.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all HealthCheck objects. +func (g *GCEAlphaHealthChecks) List(ctx context.Context, fl *filter.F) ([]*alpha.HealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.HealthChecks.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.HealthCheck + f := func(l *alpha.HealthCheckList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert HealthCheck with key of value obj. +func (g *GCEAlphaHealthChecks) Insert(ctx context.Context, key meta.Key, obj *alpha.HealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.HealthChecks.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the HealthCheck referenced by key. +func (g *GCEAlphaHealthChecks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.HealthChecks.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEAlphaHealthChecks. +func (g *GCEAlphaHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *alpha.HealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "HealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("alpha"), + Service: "HealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.HealthChecks.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// HttpHealthChecks is an interface that allows for mocking of HttpHealthChecks. +type HttpHealthChecks interface { + Get(ctx context.Context, key meta.Key) (*ga.HttpHealthCheck, error) + List(ctx context.Context, fl *filter.F) ([]*ga.HttpHealthCheck, error) + Insert(ctx context.Context, key meta.Key, obj *ga.HttpHealthCheck) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *ga.HttpHealthCheck) error +} + +// NewMockHttpHealthChecks returns a new mock for HttpHealthChecks. +func NewMockHttpHealthChecks(objs map[meta.Key]*MockHttpHealthChecksObj) *MockHttpHealthChecks { + mock := &MockHttpHealthChecks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockHttpHealthChecks is the mock for HttpHealthChecks. +type MockHttpHealthChecks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockHttpHealthChecksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockHttpHealthChecks, ctx context.Context, key meta.Key) (bool, *ga.HttpHealthCheck, error) + ListHook func(m *MockHttpHealthChecks, ctx context.Context, fl *filter.F) (bool, []*ga.HttpHealthCheck, error) + InsertHook func(m *MockHttpHealthChecks, ctx context.Context, key meta.Key, obj *ga.HttpHealthCheck) (bool, error) + DeleteHook func(m *MockHttpHealthChecks, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockHttpHealthChecks, context.Context, meta.Key, *ga.HttpHealthCheck) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockHttpHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HttpHealthCheck, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHttpHealthChecks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockHttpHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockHttpHealthChecks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHttpHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHttpHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockHttpHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpHealthCheck, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockHttpHealthChecks.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockHttpHealthChecks.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.HttpHealthCheck + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockHttpHealthChecks.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockHttpHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HttpHealthCheck) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockHttpHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockHttpHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockHttpHealthChecks %v exists", key), + } + glog.V(5).Infof("MockHttpHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "httpHealthChecks", key) + } + + m.Objects[key] = &MockHttpHealthChecksObj{obj} + glog.V(5).Infof("MockHttpHealthChecks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockHttpHealthChecks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHttpHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockHttpHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHttpHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHttpHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockHttpHealthChecks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockHttpHealthChecks) Obj(o *ga.HttpHealthCheck) *MockHttpHealthChecksObj { + return &MockHttpHealthChecksObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockHttpHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HttpHealthCheck) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEHttpHealthChecks is a simplifying adapter for the GCE HttpHealthChecks. +type GCEHttpHealthChecks struct { + s *Service +} + +// Get the HttpHealthCheck named by key. +func (g *GCEHttpHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HttpHealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "HttpHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HttpHealthChecks.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all HttpHealthCheck objects. +func (g *GCEHttpHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpHealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "HttpHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HttpHealthChecks.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.HttpHealthCheck + f := func(l *ga.HttpHealthCheckList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert HttpHealthCheck with key of value obj. +func (g *GCEHttpHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HttpHealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "HttpHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.HttpHealthChecks.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the HttpHealthCheck referenced by key. +func (g *GCEHttpHealthChecks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "HttpHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HttpHealthChecks.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEHttpHealthChecks. +func (g *GCEHttpHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HttpHealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "HttpHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HttpHealthChecks.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// HttpsHealthChecks is an interface that allows for mocking of HttpsHealthChecks. +type HttpsHealthChecks interface { + Get(ctx context.Context, key meta.Key) (*ga.HttpsHealthCheck, error) + List(ctx context.Context, fl *filter.F) ([]*ga.HttpsHealthCheck, error) + Insert(ctx context.Context, key meta.Key, obj *ga.HttpsHealthCheck) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *ga.HttpsHealthCheck) error +} + +// NewMockHttpsHealthChecks returns a new mock for HttpsHealthChecks. +func NewMockHttpsHealthChecks(objs map[meta.Key]*MockHttpsHealthChecksObj) *MockHttpsHealthChecks { + mock := &MockHttpsHealthChecks{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockHttpsHealthChecks is the mock for HttpsHealthChecks. +type MockHttpsHealthChecks struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockHttpsHealthChecksObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockHttpsHealthChecks, ctx context.Context, key meta.Key) (bool, *ga.HttpsHealthCheck, error) + ListHook func(m *MockHttpsHealthChecks, ctx context.Context, fl *filter.F) (bool, []*ga.HttpsHealthCheck, error) + InsertHook func(m *MockHttpsHealthChecks, ctx context.Context, key meta.Key, obj *ga.HttpsHealthCheck) (bool, error) + DeleteHook func(m *MockHttpsHealthChecks, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockHttpsHealthChecks, context.Context, meta.Key, *ga.HttpsHealthCheck) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockHttpsHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HttpsHealthCheck, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHttpsHealthChecks.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockHttpsHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockHttpsHealthChecks.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHttpsHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHttpsHealthChecks.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockHttpsHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpsHealthCheck, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockHttpsHealthChecks.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockHttpsHealthChecks.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.HttpsHealthCheck + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockHttpsHealthChecks.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockHttpsHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HttpsHealthCheck) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockHttpsHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockHttpsHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockHttpsHealthChecks %v exists", key), + } + glog.V(5).Infof("MockHttpsHealthChecks.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "httpsHealthChecks", key) + } + + m.Objects[key] = &MockHttpsHealthChecksObj{obj} + glog.V(5).Infof("MockHttpsHealthChecks.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockHttpsHealthChecks) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockHttpsHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockHttpsHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockHttpsHealthChecks %v not found", key), + } + glog.V(5).Infof("MockHttpsHealthChecks.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockHttpsHealthChecks.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockHttpsHealthChecks) Obj(o *ga.HttpsHealthCheck) *MockHttpsHealthChecksObj { + return &MockHttpsHealthChecksObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockHttpsHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HttpsHealthCheck) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEHttpsHealthChecks is a simplifying adapter for the GCE HttpsHealthChecks. +type GCEHttpsHealthChecks struct { + s *Service +} + +// Get the HttpsHealthCheck named by key. +func (g *GCEHttpsHealthChecks) Get(ctx context.Context, key meta.Key) (*ga.HttpsHealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpsHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "HttpsHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HttpsHealthChecks.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all HttpsHealthCheck objects. +func (g *GCEHttpsHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpsHealthCheck, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpsHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "HttpsHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.HttpsHealthChecks.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.HttpsHealthCheck + f := func(l *ga.HttpsHealthCheckList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert HttpsHealthCheck with key of value obj. +func (g *GCEHttpsHealthChecks) Insert(ctx context.Context, key meta.Key, obj *ga.HttpsHealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpsHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "HttpsHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.HttpsHealthChecks.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the HttpsHealthCheck referenced by key. +func (g *GCEHttpsHealthChecks) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpsHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "HttpsHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HttpsHealthChecks.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEHttpsHealthChecks. +func (g *GCEHttpsHealthChecks) Update(ctx context.Context, key meta.Key, arg0 *ga.HttpsHealthCheck) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "HttpsHealthChecks") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "HttpsHealthChecks", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.HttpsHealthChecks.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// InstanceGroups is an interface that allows for mocking of InstanceGroups. +type InstanceGroups interface { + Get(ctx context.Context, key meta.Key) (*ga.InstanceGroup, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroup, error) + Insert(ctx context.Context, key meta.Key, obj *ga.InstanceGroup) error + Delete(ctx context.Context, key meta.Key) error + AddInstances(context.Context, meta.Key, *ga.InstanceGroupsAddInstancesRequest) error + ListInstances(context.Context, meta.Key, *ga.InstanceGroupsListInstancesRequest) (*ga.InstanceGroupsListInstances, error) + RemoveInstances(context.Context, meta.Key, *ga.InstanceGroupsRemoveInstancesRequest) error + SetNamedPorts(context.Context, meta.Key, *ga.InstanceGroupsSetNamedPortsRequest) error +} + +// NewMockInstanceGroups returns a new mock for InstanceGroups. +func NewMockInstanceGroups(objs map[meta.Key]*MockInstanceGroupsObj) *MockInstanceGroups { + mock := &MockInstanceGroups{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockInstanceGroups is the mock for InstanceGroups. +type MockInstanceGroups struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockInstanceGroupsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockInstanceGroups, ctx context.Context, key meta.Key) (bool, *ga.InstanceGroup, error) + ListHook func(m *MockInstanceGroups, ctx context.Context, zone string, fl *filter.F) (bool, []*ga.InstanceGroup, error) + InsertHook func(m *MockInstanceGroups, ctx context.Context, key meta.Key, obj *ga.InstanceGroup) (bool, error) + DeleteHook func(m *MockInstanceGroups, ctx context.Context, key meta.Key) (bool, error) + AddInstancesHook func(*MockInstanceGroups, context.Context, meta.Key, *ga.InstanceGroupsAddInstancesRequest) error + ListInstancesHook func(*MockInstanceGroups, context.Context, meta.Key, *ga.InstanceGroupsListInstancesRequest) (*ga.InstanceGroupsListInstances, error) + RemoveInstancesHook func(*MockInstanceGroups, context.Context, meta.Key, *ga.InstanceGroupsRemoveInstancesRequest) error + SetNamedPortsHook func(*MockInstanceGroups, context.Context, meta.Key, *ga.InstanceGroupsSetNamedPortsRequest) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockInstanceGroups) Get(ctx context.Context, key meta.Key) (*ga.InstanceGroup, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockInstanceGroups.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockInstanceGroups.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockInstanceGroups.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockInstanceGroups %v not found", key), + } + glog.V(5).Infof("MockInstanceGroups.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockInstanceGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroup, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockInstanceGroups.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockInstanceGroups.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.InstanceGroup + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockInstanceGroups.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockInstanceGroups) Insert(ctx context.Context, key meta.Key, obj *ga.InstanceGroup) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockInstanceGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockInstanceGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockInstanceGroups %v exists", key), + } + glog.V(5).Infof("MockInstanceGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "instanceGroups", key) + } + + m.Objects[key] = &MockInstanceGroupsObj{obj} + glog.V(5).Infof("MockInstanceGroups.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockInstanceGroups) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockInstanceGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockInstanceGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockInstanceGroups %v not found", key), + } + glog.V(5).Infof("MockInstanceGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockInstanceGroups.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockInstanceGroups) Obj(o *ga.InstanceGroup) *MockInstanceGroupsObj { + return &MockInstanceGroupsObj{o} +} + +// AddInstances is a mock for the corresponding method. +func (m *MockInstanceGroups) AddInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsAddInstancesRequest) error { + if m.AddInstancesHook != nil { + return m.AddInstancesHook(m, ctx, key, arg0) + } + return nil +} + +// ListInstances is a mock for the corresponding method. +func (m *MockInstanceGroups) ListInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsListInstancesRequest) (*ga.InstanceGroupsListInstances, error) { + if m.ListInstancesHook != nil { + return m.ListInstancesHook(m, ctx, key, arg0) + } + return nil, fmt.Errorf("ListInstancesHook must be set") +} + +// RemoveInstances is a mock for the corresponding method. +func (m *MockInstanceGroups) RemoveInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsRemoveInstancesRequest) error { + if m.RemoveInstancesHook != nil { + return m.RemoveInstancesHook(m, ctx, key, arg0) + } + return nil +} + +// SetNamedPorts is a mock for the corresponding method. +func (m *MockInstanceGroups) SetNamedPorts(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsSetNamedPortsRequest) error { + if m.SetNamedPortsHook != nil { + return m.SetNamedPortsHook(m, ctx, key, arg0) + } + return nil +} + +// GCEInstanceGroups is a simplifying adapter for the GCE InstanceGroups. +type GCEInstanceGroups struct { + s *Service +} + +// Get the InstanceGroup named by key. +func (g *GCEInstanceGroups) Get(ctx context.Context, key meta.Key) (*ga.InstanceGroup, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.InstanceGroups.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all InstanceGroup objects. +func (g *GCEInstanceGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroup, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.InstanceGroups.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.InstanceGroup + f := func(l *ga.InstanceGroupList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert InstanceGroup with key of value obj. +func (g *GCEInstanceGroups) Insert(ctx context.Context, key meta.Key, obj *ga.InstanceGroup) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.InstanceGroups.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the InstanceGroup referenced by key. +func (g *GCEInstanceGroups) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.InstanceGroups.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AddInstances is a method on GCEInstanceGroups. +func (g *GCEInstanceGroups) AddInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsAddInstancesRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AddInstances", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.InstanceGroups.AddInstances(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// ListInstances is a method on GCEInstanceGroups. +func (g *GCEInstanceGroups) ListInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsListInstancesRequest) (*ga.InstanceGroupsListInstances, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "ListInstances", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.InstanceGroups.ListInstances(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + return call.Do() +} + +// RemoveInstances is a method on GCEInstanceGroups. +func (g *GCEInstanceGroups) RemoveInstances(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsRemoveInstancesRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "RemoveInstances", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.InstanceGroups.RemoveInstances(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SetNamedPorts is a method on GCEInstanceGroups. +func (g *GCEInstanceGroups) SetNamedPorts(ctx context.Context, key meta.Key, arg0 *ga.InstanceGroupsSetNamedPortsRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "InstanceGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetNamedPorts", + Version: meta.Version("ga"), + Service: "InstanceGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.InstanceGroups.SetNamedPorts(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Instances is an interface that allows for mocking of Instances. +type Instances interface { + Get(ctx context.Context, key meta.Key) (*ga.Instance, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Instance, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Instance) error + Delete(ctx context.Context, key meta.Key) error + AttachDisk(context.Context, meta.Key, *ga.AttachedDisk) error + DetachDisk(context.Context, meta.Key, string) error +} + +// NewMockInstances returns a new mock for Instances. +func NewMockInstances(objs map[meta.Key]*MockInstancesObj) *MockInstances { + mock := &MockInstances{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockInstances is the mock for Instances. +type MockInstances struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockInstancesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockInstances, ctx context.Context, key meta.Key) (bool, *ga.Instance, error) + ListHook func(m *MockInstances, ctx context.Context, zone string, fl *filter.F) (bool, []*ga.Instance, error) + InsertHook func(m *MockInstances, ctx context.Context, key meta.Key, obj *ga.Instance) (bool, error) + DeleteHook func(m *MockInstances, ctx context.Context, key meta.Key) (bool, error) + AttachDiskHook func(*MockInstances, context.Context, meta.Key, *ga.AttachedDisk) error + DetachDiskHook func(*MockInstances, context.Context, meta.Key, string) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockInstances) Get(ctx context.Context, key meta.Key) (*ga.Instance, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockInstances.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockInstances.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockInstances %v not found", key), + } + glog.V(5).Infof("MockInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Instance, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockInstances.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockInstances.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Instance + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockInstances.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockInstances) Insert(ctx context.Context, key meta.Key, obj *ga.Instance) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockInstances %v exists", key), + } + glog.V(5).Infof("MockInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "instances", key) + } + + m.Objects[key] = &MockInstancesObj{obj} + glog.V(5).Infof("MockInstances.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockInstances) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockInstances %v not found", key), + } + glog.V(5).Infof("MockInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockInstances.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockInstances) Obj(o *ga.Instance) *MockInstancesObj { + return &MockInstancesObj{o} +} + +// AttachDisk is a mock for the corresponding method. +func (m *MockInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *ga.AttachedDisk) error { + if m.AttachDiskHook != nil { + return m.AttachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// DetachDisk is a mock for the corresponding method. +func (m *MockInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + if m.DetachDiskHook != nil { + return m.DetachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// GCEInstances is a simplifying adapter for the GCE Instances. +type GCEInstances struct { + s *Service +} + +// Get the Instance named by key. +func (g *GCEInstances) Get(ctx context.Context, key meta.Key) (*ga.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Instances.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Instance objects. +func (g *GCEInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Instances.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Instance + f := func(l *ga.InstanceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Instance with key of value obj. +func (g *GCEInstances) Insert(ctx context.Context, key meta.Key, obj *ga.Instance) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.Instances.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Instance referenced by key. +func (g *GCEInstances) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Instances.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AttachDisk is a method on GCEInstances. +func (g *GCEInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *ga.AttachedDisk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AttachDisk", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Instances.AttachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// DetachDisk is a method on GCEInstances. +func (g *GCEInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "DetachDisk", + Version: meta.Version("ga"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Instances.DetachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// BetaInstances is an interface that allows for mocking of Instances. +type BetaInstances interface { + Get(ctx context.Context, key meta.Key) (*beta.Instance, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*beta.Instance, error) + Insert(ctx context.Context, key meta.Key, obj *beta.Instance) error + Delete(ctx context.Context, key meta.Key) error + AttachDisk(context.Context, meta.Key, *beta.AttachedDisk) error + DetachDisk(context.Context, meta.Key, string) error +} + +// NewMockBetaInstances returns a new mock for Instances. +func NewMockBetaInstances(objs map[meta.Key]*MockInstancesObj) *MockBetaInstances { + mock := &MockBetaInstances{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockBetaInstances is the mock for Instances. +type MockBetaInstances struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockInstancesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockBetaInstances, ctx context.Context, key meta.Key) (bool, *beta.Instance, error) + ListHook func(m *MockBetaInstances, ctx context.Context, zone string, fl *filter.F) (bool, []*beta.Instance, error) + InsertHook func(m *MockBetaInstances, ctx context.Context, key meta.Key, obj *beta.Instance) (bool, error) + DeleteHook func(m *MockBetaInstances, ctx context.Context, key meta.Key) (bool, error) + AttachDiskHook func(*MockBetaInstances, context.Context, meta.Key, *beta.AttachedDisk) error + DetachDiskHook func(*MockBetaInstances, context.Context, meta.Key, string) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockBetaInstances) Get(ctx context.Context, key meta.Key) (*beta.Instance, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBetaInstances.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockBetaInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToBeta() + glog.V(5).Infof("MockBetaInstances.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaInstances %v not found", key), + } + glog.V(5).Infof("MockBetaInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockBetaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*beta.Instance, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockBetaInstances.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockBetaInstances.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*beta.Instance + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToBeta()) { + continue + } + objs = append(objs, obj.ToBeta()) + } + + glog.V(5).Infof("MockBetaInstances.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockBetaInstances) Insert(ctx context.Context, key meta.Key, obj *beta.Instance) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockBetaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockBetaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockBetaInstances %v exists", key), + } + glog.V(5).Infof("MockBetaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionBeta, "mock-project", "instances", key) + } + + m.Objects[key] = &MockInstancesObj{obj} + glog.V(5).Infof("MockBetaInstances.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockBetaInstances) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockBetaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockBetaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockBetaInstances %v not found", key), + } + glog.V(5).Infof("MockBetaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockBetaInstances.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockBetaInstances) Obj(o *beta.Instance) *MockInstancesObj { + return &MockInstancesObj{o} +} + +// AttachDisk is a mock for the corresponding method. +func (m *MockBetaInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *beta.AttachedDisk) error { + if m.AttachDiskHook != nil { + return m.AttachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// DetachDisk is a mock for the corresponding method. +func (m *MockBetaInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + if m.DetachDiskHook != nil { + return m.DetachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// GCEBetaInstances is a simplifying adapter for the GCE Instances. +type GCEBetaInstances struct { + s *Service +} + +// Get the Instance named by key. +func (g *GCEBetaInstances) Get(ctx context.Context, key meta.Key) (*beta.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Beta.Instances.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Instance objects. +func (g *GCEBetaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*beta.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Beta.Instances.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*beta.Instance + f := func(l *beta.InstanceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Instance with key of value obj. +func (g *GCEBetaInstances) Insert(ctx context.Context, key meta.Key, obj *beta.Instance) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Beta.Instances.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Instance referenced by key. +func (g *GCEBetaInstances) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Beta.Instances.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AttachDisk is a method on GCEBetaInstances. +func (g *GCEBetaInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *beta.AttachedDisk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AttachDisk", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Beta.Instances.AttachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// DetachDisk is a method on GCEBetaInstances. +func (g *GCEBetaInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "beta", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "DetachDisk", + Version: meta.Version("beta"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Beta.Instances.DetachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaInstances is an interface that allows for mocking of Instances. +type AlphaInstances interface { + Get(ctx context.Context, key meta.Key) (*alpha.Instance, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Instance, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.Instance) error + Delete(ctx context.Context, key meta.Key) error + AttachDisk(context.Context, meta.Key, *alpha.AttachedDisk) error + DetachDisk(context.Context, meta.Key, string) error + UpdateNetworkInterface(context.Context, meta.Key, string, *alpha.NetworkInterface) error +} + +// NewMockAlphaInstances returns a new mock for Instances. +func NewMockAlphaInstances(objs map[meta.Key]*MockInstancesObj) *MockAlphaInstances { + mock := &MockAlphaInstances{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaInstances is the mock for Instances. +type MockAlphaInstances struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockInstancesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaInstances, ctx context.Context, key meta.Key) (bool, *alpha.Instance, error) + ListHook func(m *MockAlphaInstances, ctx context.Context, zone string, fl *filter.F) (bool, []*alpha.Instance, error) + InsertHook func(m *MockAlphaInstances, ctx context.Context, key meta.Key, obj *alpha.Instance) (bool, error) + DeleteHook func(m *MockAlphaInstances, ctx context.Context, key meta.Key) (bool, error) + AttachDiskHook func(*MockAlphaInstances, context.Context, meta.Key, *alpha.AttachedDisk) error + DetachDiskHook func(*MockAlphaInstances, context.Context, meta.Key, string) error + UpdateNetworkInterfaceHook func(*MockAlphaInstances, context.Context, meta.Key, string, *alpha.NetworkInterface) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaInstances) Get(ctx context.Context, key meta.Key) (*alpha.Instance, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaInstances.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaInstances.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaInstances %v not found", key), + } + glog.V(5).Infof("MockAlphaInstances.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockAlphaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Instance, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockAlphaInstances.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaInstances.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.Instance + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaInstances.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaInstances) Insert(ctx context.Context, key meta.Key, obj *alpha.Instance) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaInstances %v exists", key), + } + glog.V(5).Infof("MockAlphaInstances.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "instances", key) + } + + m.Objects[key] = &MockInstancesObj{obj} + glog.V(5).Infof("MockAlphaInstances.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaInstances) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaInstances %v not found", key), + } + glog.V(5).Infof("MockAlphaInstances.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaInstances.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaInstances) Obj(o *alpha.Instance) *MockInstancesObj { + return &MockInstancesObj{o} +} + +// AttachDisk is a mock for the corresponding method. +func (m *MockAlphaInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *alpha.AttachedDisk) error { + if m.AttachDiskHook != nil { + return m.AttachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// DetachDisk is a mock for the corresponding method. +func (m *MockAlphaInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + if m.DetachDiskHook != nil { + return m.DetachDiskHook(m, ctx, key, arg0) + } + return nil +} + +// UpdateNetworkInterface is a mock for the corresponding method. +func (m *MockAlphaInstances) UpdateNetworkInterface(ctx context.Context, key meta.Key, arg0 string, arg1 *alpha.NetworkInterface) error { + if m.UpdateNetworkInterfaceHook != nil { + return m.UpdateNetworkInterfaceHook(m, ctx, key, arg0, arg1) + } + return nil +} + +// GCEAlphaInstances is a simplifying adapter for the GCE Instances. +type GCEAlphaInstances struct { + s *Service +} + +// Get the Instance named by key. +func (g *GCEAlphaInstances) Get(ctx context.Context, key meta.Key) (*alpha.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Instances.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Instance objects. +func (g *GCEAlphaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Instance, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.Instances.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.Instance + f := func(l *alpha.InstanceList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Instance with key of value obj. +func (g *GCEAlphaInstances) Insert(ctx context.Context, key meta.Key, obj *alpha.Instance) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.Instances.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Instance referenced by key. +func (g *GCEAlphaInstances) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Instances.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AttachDisk is a method on GCEAlphaInstances. +func (g *GCEAlphaInstances) AttachDisk(ctx context.Context, key meta.Key, arg0 *alpha.AttachedDisk) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AttachDisk", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Instances.AttachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// DetachDisk is a method on GCEAlphaInstances. +func (g *GCEAlphaInstances) DetachDisk(ctx context.Context, key meta.Key, arg0 string) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "DetachDisk", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Instances.DetachDisk(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// UpdateNetworkInterface is a method on GCEAlphaInstances. +func (g *GCEAlphaInstances) UpdateNetworkInterface(ctx context.Context, key meta.Key, arg0 string, arg1 *alpha.NetworkInterface) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "Instances") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "UpdateNetworkInterface", + Version: meta.Version("alpha"), + Service: "Instances", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.Instances.UpdateNetworkInterface(projectID, key.Zone, key.Name, arg0, arg1) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AlphaNetworkEndpointGroups is an interface that allows for mocking of NetworkEndpointGroups. +type AlphaNetworkEndpointGroups interface { + Get(ctx context.Context, key meta.Key) (*alpha.NetworkEndpointGroup, error) + List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.NetworkEndpointGroup, error) + Insert(ctx context.Context, key meta.Key, obj *alpha.NetworkEndpointGroup) error + Delete(ctx context.Context, key meta.Key) error + AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.NetworkEndpointGroup, error) + AttachNetworkEndpoints(context.Context, meta.Key, *alpha.NetworkEndpointGroupsAttachEndpointsRequest) error + DetachNetworkEndpoints(context.Context, meta.Key, *alpha.NetworkEndpointGroupsDetachEndpointsRequest) error +} + +// NewMockAlphaNetworkEndpointGroups returns a new mock for NetworkEndpointGroups. +func NewMockAlphaNetworkEndpointGroups(objs map[meta.Key]*MockNetworkEndpointGroupsObj) *MockAlphaNetworkEndpointGroups { + mock := &MockAlphaNetworkEndpointGroups{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockAlphaNetworkEndpointGroups is the mock for NetworkEndpointGroups. +type MockAlphaNetworkEndpointGroups struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockNetworkEndpointGroupsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + AggregatedListError *error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockAlphaNetworkEndpointGroups, ctx context.Context, key meta.Key) (bool, *alpha.NetworkEndpointGroup, error) + ListHook func(m *MockAlphaNetworkEndpointGroups, ctx context.Context, zone string, fl *filter.F) (bool, []*alpha.NetworkEndpointGroup, error) + InsertHook func(m *MockAlphaNetworkEndpointGroups, ctx context.Context, key meta.Key, obj *alpha.NetworkEndpointGroup) (bool, error) + DeleteHook func(m *MockAlphaNetworkEndpointGroups, ctx context.Context, key meta.Key) (bool, error) + AggregatedListHook func(m *MockAlphaNetworkEndpointGroups, ctx context.Context, fl *filter.F) (bool, map[string][]*alpha.NetworkEndpointGroup, error) + AttachNetworkEndpointsHook func(*MockAlphaNetworkEndpointGroups, context.Context, meta.Key, *alpha.NetworkEndpointGroupsAttachEndpointsRequest) error + DetachNetworkEndpointsHook func(*MockAlphaNetworkEndpointGroups, context.Context, meta.Key, *alpha.NetworkEndpointGroupsDetachEndpointsRequest) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockAlphaNetworkEndpointGroups) Get(ctx context.Context, key meta.Key) (*alpha.NetworkEndpointGroup, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToAlpha() + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaNetworkEndpointGroups %v not found", key), + } + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given zone. +func (m *MockAlphaNetworkEndpointGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.NetworkEndpointGroup, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, zone, fl); intercept { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.List(%v, %q, %v) = [%v items], %v", ctx, zone, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.List(%v, %q, %v) = nil, %v", ctx, zone, fl, err) + + return nil, *m.ListError + } + + var objs []*alpha.NetworkEndpointGroup + for key, obj := range m.Objects { + if key.Zone != zone { + continue + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs = append(objs, obj.ToAlpha()) + } + + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.List(%v, %q, %v) = [%v items], nil", ctx, zone, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockAlphaNetworkEndpointGroups) Insert(ctx context.Context, key meta.Key, obj *alpha.NetworkEndpointGroup) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockAlphaNetworkEndpointGroups %v exists", key), + } + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionAlpha, "mock-project", "networkEndpointGroups", key) + } + + m.Objects[key] = &MockNetworkEndpointGroupsObj{obj} + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockAlphaNetworkEndpointGroups) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockAlphaNetworkEndpointGroups %v not found", key), + } + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// AggregatedList is a mock for AggregatedList. +func (m *MockAlphaNetworkEndpointGroups) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.NetworkEndpointGroup, error) { + if m.AggregatedListHook != nil { + if intercept, objs, err := m.AggregatedListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.AggregatedList(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.AggregatedListError != nil { + err := *m.AggregatedListError + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.AggregatedList(%v, %v) = nil, %v", ctx, fl, err) + return nil, err + } + + objs := map[string][]*alpha.NetworkEndpointGroup{} + for _, obj := range m.Objects { + res, err := ParseResourceURL(obj.ToAlpha().SelfLink) + location := res.Key.Zone + if err != nil { + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.AggregatedList(%v, %v) = nil, %v", ctx, fl, err) + return nil, err + } + if !fl.Match(obj.ToAlpha()) { + continue + } + objs[location] = append(objs[location], obj.ToAlpha()) + } + glog.V(5).Infof("MockAlphaNetworkEndpointGroups.AggregatedList(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Obj wraps the object for use in the mock. +func (m *MockAlphaNetworkEndpointGroups) Obj(o *alpha.NetworkEndpointGroup) *MockNetworkEndpointGroupsObj { + return &MockNetworkEndpointGroupsObj{o} +} + +// AttachNetworkEndpoints is a mock for the corresponding method. +func (m *MockAlphaNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key meta.Key, arg0 *alpha.NetworkEndpointGroupsAttachEndpointsRequest) error { + if m.AttachNetworkEndpointsHook != nil { + return m.AttachNetworkEndpointsHook(m, ctx, key, arg0) + } + return nil +} + +// DetachNetworkEndpoints is a mock for the corresponding method. +func (m *MockAlphaNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key meta.Key, arg0 *alpha.NetworkEndpointGroupsDetachEndpointsRequest) error { + if m.DetachNetworkEndpointsHook != nil { + return m.DetachNetworkEndpointsHook(m, ctx, key, arg0) + } + return nil +} + +// GCEAlphaNetworkEndpointGroups is a simplifying adapter for the GCE NetworkEndpointGroups. +type GCEAlphaNetworkEndpointGroups struct { + s *Service +} + +// Get the NetworkEndpointGroup named by key. +func (g *GCEAlphaNetworkEndpointGroups) Get(ctx context.Context, key meta.Key) (*alpha.NetworkEndpointGroup, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.NetworkEndpointGroups.Get(projectID, key.Zone, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all NetworkEndpointGroup objects. +func (g *GCEAlphaNetworkEndpointGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.NetworkEndpointGroup, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.Alpha.NetworkEndpointGroups.List(projectID, zone) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*alpha.NetworkEndpointGroup + f := func(l *alpha.NetworkEndpointGroupList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert NetworkEndpointGroup with key of value obj. +func (g *GCEAlphaNetworkEndpointGroups) Insert(ctx context.Context, key meta.Key, obj *alpha.NetworkEndpointGroup) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.Alpha.NetworkEndpointGroups.Insert(projectID, key.Zone, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the NetworkEndpointGroup referenced by key. +func (g *GCEAlphaNetworkEndpointGroups) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.NetworkEndpointGroups.Delete(projectID, key.Zone, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AggregatedList lists all resources of the given type across all locations. +func (g *GCEAlphaNetworkEndpointGroups) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.NetworkEndpointGroup, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AggregatedList", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + + call := g.s.Alpha.NetworkEndpointGroups.AggregatedList(projectID) + call.Context(ctx) + if fl != filter.None { + call.Filter(fl.String()) + } + + all := map[string][]*alpha.NetworkEndpointGroup{} + f := func(l *alpha.NetworkEndpointGroupAggregatedList) error { + for k, v := range l.Items { + all[k] = append(all[k], v.NetworkEndpointGroups...) + } + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// AttachNetworkEndpoints is a method on GCEAlphaNetworkEndpointGroups. +func (g *GCEAlphaNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key meta.Key, arg0 *alpha.NetworkEndpointGroupsAttachEndpointsRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AttachNetworkEndpoints", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.NetworkEndpointGroups.AttachNetworkEndpoints(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// DetachNetworkEndpoints is a method on GCEAlphaNetworkEndpointGroups. +func (g *GCEAlphaNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key meta.Key, arg0 *alpha.NetworkEndpointGroupsDetachEndpointsRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "alpha", "NetworkEndpointGroups") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "DetachNetworkEndpoints", + Version: meta.Version("alpha"), + Service: "NetworkEndpointGroups", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.Alpha.NetworkEndpointGroups.DetachNetworkEndpoints(projectID, key.Zone, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Projects is an interface that allows for mocking of Projects. +type Projects interface { + // ProjectsOps is an interface with additional non-CRUD type methods. + // This interface is expected to be implemented by hand (non-autogenerated). + ProjectsOps +} + +// NewMockProjects returns a new mock for Projects. +func NewMockProjects(objs map[meta.Key]*MockProjectsObj) *MockProjects { + mock := &MockProjects{ + Objects: objs, + } + return mock +} + +// MockProjects is the mock for Projects. +type MockProjects struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockProjectsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Obj wraps the object for use in the mock. +func (m *MockProjects) Obj(o *ga.Project) *MockProjectsObj { + return &MockProjectsObj{o} +} + +// GCEProjects is a simplifying adapter for the GCE Projects. +type GCEProjects struct { + s *Service +} + +// Regions is an interface that allows for mocking of Regions. +type Regions interface { + Get(ctx context.Context, key meta.Key) (*ga.Region, error) + List(ctx context.Context, fl *filter.F) ([]*ga.Region, error) +} + +// NewMockRegions returns a new mock for Regions. +func NewMockRegions(objs map[meta.Key]*MockRegionsObj) *MockRegions { + mock := &MockRegions{ + Objects: objs, + GetError: map[meta.Key]error{}, + } + return mock +} + +// MockRegions is the mock for Regions. +type MockRegions struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRegionsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockRegions, ctx context.Context, key meta.Key) (bool, *ga.Region, error) + ListHook func(m *MockRegions, ctx context.Context, fl *filter.F) (bool, []*ga.Region, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockRegions) Get(ctx context.Context, key meta.Key) (*ga.Region, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockRegions.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockRegions.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockRegions.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockRegions %v not found", key), + } + glog.V(5).Infof("MockRegions.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockRegions) List(ctx context.Context, fl *filter.F) ([]*ga.Region, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockRegions.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockRegions.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Region + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockRegions.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Obj wraps the object for use in the mock. +func (m *MockRegions) Obj(o *ga.Region) *MockRegionsObj { + return &MockRegionsObj{o} +} + +// GCERegions is a simplifying adapter for the GCE Regions. +type GCERegions struct { + s *Service +} + +// Get the Region named by key. +func (g *GCERegions) Get(ctx context.Context, key meta.Key) (*ga.Region, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Regions") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Regions", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Regions.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Region objects. +func (g *GCERegions) List(ctx context.Context, fl *filter.F) ([]*ga.Region, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Regions") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Regions", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Regions.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Region + f := func(l *ga.RegionList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Routes is an interface that allows for mocking of Routes. +type Routes interface { + Get(ctx context.Context, key meta.Key) (*ga.Route, error) + List(ctx context.Context, fl *filter.F) ([]*ga.Route, error) + Insert(ctx context.Context, key meta.Key, obj *ga.Route) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockRoutes returns a new mock for Routes. +func NewMockRoutes(objs map[meta.Key]*MockRoutesObj) *MockRoutes { + mock := &MockRoutes{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockRoutes is the mock for Routes. +type MockRoutes struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockRoutesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockRoutes, ctx context.Context, key meta.Key) (bool, *ga.Route, error) + ListHook func(m *MockRoutes, ctx context.Context, fl *filter.F) (bool, []*ga.Route, error) + InsertHook func(m *MockRoutes, ctx context.Context, key meta.Key, obj *ga.Route) (bool, error) + DeleteHook func(m *MockRoutes, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockRoutes) Get(ctx context.Context, key meta.Key) (*ga.Route, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockRoutes.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockRoutes.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockRoutes.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockRoutes %v not found", key), + } + glog.V(5).Infof("MockRoutes.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockRoutes) List(ctx context.Context, fl *filter.F) ([]*ga.Route, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockRoutes.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockRoutes.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Route + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockRoutes.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockRoutes) Insert(ctx context.Context, key meta.Key, obj *ga.Route) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockRoutes.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockRoutes.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockRoutes %v exists", key), + } + glog.V(5).Infof("MockRoutes.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "routes", key) + } + + m.Objects[key] = &MockRoutesObj{obj} + glog.V(5).Infof("MockRoutes.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockRoutes) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockRoutes.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockRoutes.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockRoutes %v not found", key), + } + glog.V(5).Infof("MockRoutes.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockRoutes.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockRoutes) Obj(o *ga.Route) *MockRoutesObj { + return &MockRoutesObj{o} +} + +// GCERoutes is a simplifying adapter for the GCE Routes. +type GCERoutes struct { + s *Service +} + +// Get the Route named by key. +func (g *GCERoutes) Get(ctx context.Context, key meta.Key) (*ga.Route, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Routes") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Routes", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Routes.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Route objects. +func (g *GCERoutes) List(ctx context.Context, fl *filter.F) ([]*ga.Route, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Routes") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Routes", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Routes.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Route + f := func(l *ga.RouteList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert Route with key of value obj. +func (g *GCERoutes) Insert(ctx context.Context, key meta.Key, obj *ga.Route) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Routes") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "Routes", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.Routes.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the Route referenced by key. +func (g *GCERoutes) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Routes") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "Routes", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Routes.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SslCertificates is an interface that allows for mocking of SslCertificates. +type SslCertificates interface { + Get(ctx context.Context, key meta.Key) (*ga.SslCertificate, error) + List(ctx context.Context, fl *filter.F) ([]*ga.SslCertificate, error) + Insert(ctx context.Context, key meta.Key, obj *ga.SslCertificate) error + Delete(ctx context.Context, key meta.Key) error +} + +// NewMockSslCertificates returns a new mock for SslCertificates. +func NewMockSslCertificates(objs map[meta.Key]*MockSslCertificatesObj) *MockSslCertificates { + mock := &MockSslCertificates{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockSslCertificates is the mock for SslCertificates. +type MockSslCertificates struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockSslCertificatesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockSslCertificates, ctx context.Context, key meta.Key) (bool, *ga.SslCertificate, error) + ListHook func(m *MockSslCertificates, ctx context.Context, fl *filter.F) (bool, []*ga.SslCertificate, error) + InsertHook func(m *MockSslCertificates, ctx context.Context, key meta.Key, obj *ga.SslCertificate) (bool, error) + DeleteHook func(m *MockSslCertificates, ctx context.Context, key meta.Key) (bool, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockSslCertificates) Get(ctx context.Context, key meta.Key) (*ga.SslCertificate, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockSslCertificates.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockSslCertificates.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockSslCertificates.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockSslCertificates %v not found", key), + } + glog.V(5).Infof("MockSslCertificates.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockSslCertificates) List(ctx context.Context, fl *filter.F) ([]*ga.SslCertificate, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockSslCertificates.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockSslCertificates.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.SslCertificate + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockSslCertificates.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockSslCertificates) Insert(ctx context.Context, key meta.Key, obj *ga.SslCertificate) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockSslCertificates %v exists", key), + } + glog.V(5).Infof("MockSslCertificates.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "sslCertificates", key) + } + + m.Objects[key] = &MockSslCertificatesObj{obj} + glog.V(5).Infof("MockSslCertificates.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockSslCertificates) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockSslCertificates %v not found", key), + } + glog.V(5).Infof("MockSslCertificates.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockSslCertificates.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockSslCertificates) Obj(o *ga.SslCertificate) *MockSslCertificatesObj { + return &MockSslCertificatesObj{o} +} + +// GCESslCertificates is a simplifying adapter for the GCE SslCertificates. +type GCESslCertificates struct { + s *Service +} + +// Get the SslCertificate named by key. +func (g *GCESslCertificates) Get(ctx context.Context, key meta.Key) (*ga.SslCertificate, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "SslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "SslCertificates", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.SslCertificates.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all SslCertificate objects. +func (g *GCESslCertificates) List(ctx context.Context, fl *filter.F) ([]*ga.SslCertificate, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "SslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "SslCertificates", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.SslCertificates.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.SslCertificate + f := func(l *ga.SslCertificateList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert SslCertificate with key of value obj. +func (g *GCESslCertificates) Insert(ctx context.Context, key meta.Key, obj *ga.SslCertificate) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "SslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "SslCertificates", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.SslCertificates.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the SslCertificate referenced by key. +func (g *GCESslCertificates) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "SslCertificates") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "SslCertificates", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.SslCertificates.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// TargetHttpProxies is an interface that allows for mocking of TargetHttpProxies. +type TargetHttpProxies interface { + Get(ctx context.Context, key meta.Key) (*ga.TargetHttpProxy, error) + List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpProxy, error) + Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpProxy) error + Delete(ctx context.Context, key meta.Key) error + SetUrlMap(context.Context, meta.Key, *ga.UrlMapReference) error +} + +// NewMockTargetHttpProxies returns a new mock for TargetHttpProxies. +func NewMockTargetHttpProxies(objs map[meta.Key]*MockTargetHttpProxiesObj) *MockTargetHttpProxies { + mock := &MockTargetHttpProxies{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockTargetHttpProxies is the mock for TargetHttpProxies. +type MockTargetHttpProxies struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockTargetHttpProxiesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockTargetHttpProxies, ctx context.Context, key meta.Key) (bool, *ga.TargetHttpProxy, error) + ListHook func(m *MockTargetHttpProxies, ctx context.Context, fl *filter.F) (bool, []*ga.TargetHttpProxy, error) + InsertHook func(m *MockTargetHttpProxies, ctx context.Context, key meta.Key, obj *ga.TargetHttpProxy) (bool, error) + DeleteHook func(m *MockTargetHttpProxies, ctx context.Context, key meta.Key) (bool, error) + SetUrlMapHook func(*MockTargetHttpProxies, context.Context, meta.Key, *ga.UrlMapReference) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockTargetHttpProxies) Get(ctx context.Context, key meta.Key) (*ga.TargetHttpProxy, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetHttpProxies.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockTargetHttpProxies.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockTargetHttpProxies.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetHttpProxies %v not found", key), + } + glog.V(5).Infof("MockTargetHttpProxies.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockTargetHttpProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpProxy, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockTargetHttpProxies.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockTargetHttpProxies.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.TargetHttpProxy + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockTargetHttpProxies.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockTargetHttpProxies) Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpProxy) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockTargetHttpProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockTargetHttpProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockTargetHttpProxies %v exists", key), + } + glog.V(5).Infof("MockTargetHttpProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "targetHttpProxies", key) + } + + m.Objects[key] = &MockTargetHttpProxiesObj{obj} + glog.V(5).Infof("MockTargetHttpProxies.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockTargetHttpProxies) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetHttpProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockTargetHttpProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetHttpProxies %v not found", key), + } + glog.V(5).Infof("MockTargetHttpProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockTargetHttpProxies.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockTargetHttpProxies) Obj(o *ga.TargetHttpProxy) *MockTargetHttpProxiesObj { + return &MockTargetHttpProxiesObj{o} +} + +// SetUrlMap is a mock for the corresponding method. +func (m *MockTargetHttpProxies) SetUrlMap(ctx context.Context, key meta.Key, arg0 *ga.UrlMapReference) error { + if m.SetUrlMapHook != nil { + return m.SetUrlMapHook(m, ctx, key, arg0) + } + return nil +} + +// GCETargetHttpProxies is a simplifying adapter for the GCE TargetHttpProxies. +type GCETargetHttpProxies struct { + s *Service +} + +// Get the TargetHttpProxy named by key. +func (g *GCETargetHttpProxies) Get(ctx context.Context, key meta.Key) (*ga.TargetHttpProxy, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "TargetHttpProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetHttpProxies.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all TargetHttpProxy objects. +func (g *GCETargetHttpProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpProxy, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "TargetHttpProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetHttpProxies.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.TargetHttpProxy + f := func(l *ga.TargetHttpProxyList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert TargetHttpProxy with key of value obj. +func (g *GCETargetHttpProxies) Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpProxy) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "TargetHttpProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.TargetHttpProxies.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the TargetHttpProxy referenced by key. +func (g *GCETargetHttpProxies) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "TargetHttpProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetHttpProxies.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SetUrlMap is a method on GCETargetHttpProxies. +func (g *GCETargetHttpProxies) SetUrlMap(ctx context.Context, key meta.Key, arg0 *ga.UrlMapReference) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetUrlMap", + Version: meta.Version("ga"), + Service: "TargetHttpProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetHttpProxies.SetUrlMap(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// TargetHttpsProxies is an interface that allows for mocking of TargetHttpsProxies. +type TargetHttpsProxies interface { + Get(ctx context.Context, key meta.Key) (*ga.TargetHttpsProxy, error) + List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpsProxy, error) + Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpsProxy) error + Delete(ctx context.Context, key meta.Key) error + SetSslCertificates(context.Context, meta.Key, *ga.TargetHttpsProxiesSetSslCertificatesRequest) error + SetUrlMap(context.Context, meta.Key, *ga.UrlMapReference) error +} + +// NewMockTargetHttpsProxies returns a new mock for TargetHttpsProxies. +func NewMockTargetHttpsProxies(objs map[meta.Key]*MockTargetHttpsProxiesObj) *MockTargetHttpsProxies { + mock := &MockTargetHttpsProxies{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockTargetHttpsProxies is the mock for TargetHttpsProxies. +type MockTargetHttpsProxies struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockTargetHttpsProxiesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockTargetHttpsProxies, ctx context.Context, key meta.Key) (bool, *ga.TargetHttpsProxy, error) + ListHook func(m *MockTargetHttpsProxies, ctx context.Context, fl *filter.F) (bool, []*ga.TargetHttpsProxy, error) + InsertHook func(m *MockTargetHttpsProxies, ctx context.Context, key meta.Key, obj *ga.TargetHttpsProxy) (bool, error) + DeleteHook func(m *MockTargetHttpsProxies, ctx context.Context, key meta.Key) (bool, error) + SetSslCertificatesHook func(*MockTargetHttpsProxies, context.Context, meta.Key, *ga.TargetHttpsProxiesSetSslCertificatesRequest) error + SetUrlMapHook func(*MockTargetHttpsProxies, context.Context, meta.Key, *ga.UrlMapReference) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockTargetHttpsProxies) Get(ctx context.Context, key meta.Key) (*ga.TargetHttpsProxy, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetHttpsProxies.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockTargetHttpsProxies.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockTargetHttpsProxies.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetHttpsProxies %v not found", key), + } + glog.V(5).Infof("MockTargetHttpsProxies.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockTargetHttpsProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpsProxy, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockTargetHttpsProxies.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockTargetHttpsProxies.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.TargetHttpsProxy + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockTargetHttpsProxies.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockTargetHttpsProxies) Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpsProxy) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockTargetHttpsProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockTargetHttpsProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockTargetHttpsProxies %v exists", key), + } + glog.V(5).Infof("MockTargetHttpsProxies.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "targetHttpsProxies", key) + } + + m.Objects[key] = &MockTargetHttpsProxiesObj{obj} + glog.V(5).Infof("MockTargetHttpsProxies.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockTargetHttpsProxies) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetHttpsProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockTargetHttpsProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetHttpsProxies %v not found", key), + } + glog.V(5).Infof("MockTargetHttpsProxies.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockTargetHttpsProxies.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockTargetHttpsProxies) Obj(o *ga.TargetHttpsProxy) *MockTargetHttpsProxiesObj { + return &MockTargetHttpsProxiesObj{o} +} + +// SetSslCertificates is a mock for the corresponding method. +func (m *MockTargetHttpsProxies) SetSslCertificates(ctx context.Context, key meta.Key, arg0 *ga.TargetHttpsProxiesSetSslCertificatesRequest) error { + if m.SetSslCertificatesHook != nil { + return m.SetSslCertificatesHook(m, ctx, key, arg0) + } + return nil +} + +// SetUrlMap is a mock for the corresponding method. +func (m *MockTargetHttpsProxies) SetUrlMap(ctx context.Context, key meta.Key, arg0 *ga.UrlMapReference) error { + if m.SetUrlMapHook != nil { + return m.SetUrlMapHook(m, ctx, key, arg0) + } + return nil +} + +// GCETargetHttpsProxies is a simplifying adapter for the GCE TargetHttpsProxies. +type GCETargetHttpsProxies struct { + s *Service +} + +// Get the TargetHttpsProxy named by key. +func (g *GCETargetHttpsProxies) Get(ctx context.Context, key meta.Key) (*ga.TargetHttpsProxy, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetHttpsProxies.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all TargetHttpsProxy objects. +func (g *GCETargetHttpsProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpsProxy, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetHttpsProxies.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.TargetHttpsProxy + f := func(l *ga.TargetHttpsProxyList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert TargetHttpsProxy with key of value obj. +func (g *GCETargetHttpsProxies) Insert(ctx context.Context, key meta.Key, obj *ga.TargetHttpsProxy) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.TargetHttpsProxies.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the TargetHttpsProxy referenced by key. +func (g *GCETargetHttpsProxies) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetHttpsProxies.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SetSslCertificates is a method on GCETargetHttpsProxies. +func (g *GCETargetHttpsProxies) SetSslCertificates(ctx context.Context, key meta.Key, arg0 *ga.TargetHttpsProxiesSetSslCertificatesRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetSslCertificates", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetHttpsProxies.SetSslCertificates(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// SetUrlMap is a method on GCETargetHttpsProxies. +func (g *GCETargetHttpsProxies) SetUrlMap(ctx context.Context, key meta.Key, arg0 *ga.UrlMapReference) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetHttpsProxies") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetUrlMap", + Version: meta.Version("ga"), + Service: "TargetHttpsProxies", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetHttpsProxies.SetUrlMap(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// TargetPools is an interface that allows for mocking of TargetPools. +type TargetPools interface { + Get(ctx context.Context, key meta.Key) (*ga.TargetPool, error) + List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetPool, error) + Insert(ctx context.Context, key meta.Key, obj *ga.TargetPool) error + Delete(ctx context.Context, key meta.Key) error + AddInstance(context.Context, meta.Key, *ga.TargetPoolsAddInstanceRequest) error + RemoveInstance(context.Context, meta.Key, *ga.TargetPoolsRemoveInstanceRequest) error +} + +// NewMockTargetPools returns a new mock for TargetPools. +func NewMockTargetPools(objs map[meta.Key]*MockTargetPoolsObj) *MockTargetPools { + mock := &MockTargetPools{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockTargetPools is the mock for TargetPools. +type MockTargetPools struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockTargetPoolsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockTargetPools, ctx context.Context, key meta.Key) (bool, *ga.TargetPool, error) + ListHook func(m *MockTargetPools, ctx context.Context, region string, fl *filter.F) (bool, []*ga.TargetPool, error) + InsertHook func(m *MockTargetPools, ctx context.Context, key meta.Key, obj *ga.TargetPool) (bool, error) + DeleteHook func(m *MockTargetPools, ctx context.Context, key meta.Key) (bool, error) + AddInstanceHook func(*MockTargetPools, context.Context, meta.Key, *ga.TargetPoolsAddInstanceRequest) error + RemoveInstanceHook func(*MockTargetPools, context.Context, meta.Key, *ga.TargetPoolsRemoveInstanceRequest) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockTargetPools) Get(ctx context.Context, key meta.Key) (*ga.TargetPool, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetPools.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockTargetPools.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockTargetPools.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetPools %v not found", key), + } + glog.V(5).Infof("MockTargetPools.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock in the given region. +func (m *MockTargetPools) List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetPool, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, region, fl); intercept { + glog.V(5).Infof("MockTargetPools.List(%v, %q, %v) = [%v items], %v", ctx, region, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockTargetPools.List(%v, %q, %v) = nil, %v", ctx, region, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.TargetPool + for key, obj := range m.Objects { + if key.Region != region { + continue + } + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockTargetPools.List(%v, %q, %v) = [%v items], nil", ctx, region, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockTargetPools) Insert(ctx context.Context, key meta.Key, obj *ga.TargetPool) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockTargetPools.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockTargetPools.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockTargetPools %v exists", key), + } + glog.V(5).Infof("MockTargetPools.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "targetPools", key) + } + + m.Objects[key] = &MockTargetPoolsObj{obj} + glog.V(5).Infof("MockTargetPools.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockTargetPools) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockTargetPools.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockTargetPools.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockTargetPools %v not found", key), + } + glog.V(5).Infof("MockTargetPools.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockTargetPools.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockTargetPools) Obj(o *ga.TargetPool) *MockTargetPoolsObj { + return &MockTargetPoolsObj{o} +} + +// AddInstance is a mock for the corresponding method. +func (m *MockTargetPools) AddInstance(ctx context.Context, key meta.Key, arg0 *ga.TargetPoolsAddInstanceRequest) error { + if m.AddInstanceHook != nil { + return m.AddInstanceHook(m, ctx, key, arg0) + } + return nil +} + +// RemoveInstance is a mock for the corresponding method. +func (m *MockTargetPools) RemoveInstance(ctx context.Context, key meta.Key, arg0 *ga.TargetPoolsRemoveInstanceRequest) error { + if m.RemoveInstanceHook != nil { + return m.RemoveInstanceHook(m, ctx, key, arg0) + } + return nil +} + +// GCETargetPools is a simplifying adapter for the GCE TargetPools. +type GCETargetPools struct { + s *Service +} + +// Get the TargetPool named by key. +func (g *GCETargetPools) Get(ctx context.Context, key meta.Key) (*ga.TargetPool, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetPools.Get(projectID, key.Region, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all TargetPool objects. +func (g *GCETargetPools) List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetPool, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.TargetPools.List(projectID, region) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.TargetPool + f := func(l *ga.TargetPoolList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert TargetPool with key of value obj. +func (g *GCETargetPools) Insert(ctx context.Context, key meta.Key, obj *ga.TargetPool) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.TargetPools.Insert(projectID, key.Region, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the TargetPool referenced by key. +func (g *GCETargetPools) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetPools.Delete(projectID, key.Region, key.Name) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// AddInstance is a method on GCETargetPools. +func (g *GCETargetPools) AddInstance(ctx context.Context, key meta.Key, arg0 *ga.TargetPoolsAddInstanceRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "AddInstance", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetPools.AddInstance(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// RemoveInstance is a method on GCETargetPools. +func (g *GCETargetPools) RemoveInstance(ctx context.Context, key meta.Key, arg0 *ga.TargetPoolsRemoveInstanceRequest) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "TargetPools") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "RemoveInstance", + Version: meta.Version("ga"), + Service: "TargetPools", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.TargetPools.RemoveInstance(projectID, key.Region, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// UrlMaps is an interface that allows for mocking of UrlMaps. +type UrlMaps interface { + Get(ctx context.Context, key meta.Key) (*ga.UrlMap, error) + List(ctx context.Context, fl *filter.F) ([]*ga.UrlMap, error) + Insert(ctx context.Context, key meta.Key, obj *ga.UrlMap) error + Delete(ctx context.Context, key meta.Key) error + Update(context.Context, meta.Key, *ga.UrlMap) error +} + +// NewMockUrlMaps returns a new mock for UrlMaps. +func NewMockUrlMaps(objs map[meta.Key]*MockUrlMapsObj) *MockUrlMaps { + mock := &MockUrlMaps{ + Objects: objs, + GetError: map[meta.Key]error{}, + InsertError: map[meta.Key]error{}, + DeleteError: map[meta.Key]error{}, + } + return mock +} + +// MockUrlMaps is the mock for UrlMaps. +type MockUrlMaps struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockUrlMapsObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + InsertError map[meta.Key]error + DeleteError map[meta.Key]error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockUrlMaps, ctx context.Context, key meta.Key) (bool, *ga.UrlMap, error) + ListHook func(m *MockUrlMaps, ctx context.Context, fl *filter.F) (bool, []*ga.UrlMap, error) + InsertHook func(m *MockUrlMaps, ctx context.Context, key meta.Key, obj *ga.UrlMap) (bool, error) + DeleteHook func(m *MockUrlMaps, ctx context.Context, key meta.Key) (bool, error) + UpdateHook func(*MockUrlMaps, context.Context, meta.Key, *ga.UrlMap) error + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockUrlMaps) Get(ctx context.Context, key meta.Key) (*ga.UrlMap, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockUrlMaps.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockUrlMaps.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockUrlMaps.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockUrlMaps %v not found", key), + } + glog.V(5).Infof("MockUrlMaps.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockUrlMaps) List(ctx context.Context, fl *filter.F) ([]*ga.UrlMap, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockUrlMaps.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockUrlMaps.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.UrlMap + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockUrlMaps.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Insert is a mock for inserting/creating a new object. +func (m *MockUrlMaps) Insert(ctx context.Context, key meta.Key, obj *ga.UrlMap) error { + if m.InsertHook != nil { + if intercept, err := m.InsertHook(m, ctx, key, obj); intercept { + glog.V(5).Infof("MockUrlMaps.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.InsertError[key]; ok { + glog.V(5).Infof("MockUrlMaps.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + if _, ok := m.Objects[key]; ok { + err := &googleapi.Error{ + Code: http.StatusConflict, + Message: fmt.Sprintf("MockUrlMaps %v exists", key), + } + glog.V(5).Infof("MockUrlMaps.Insert(%v, %v, %+v) = %v", ctx, key, obj, err) + return err + } + + obj.Name = key.Name + if obj.SelfLink == "" { + obj.SelfLink = SelfLink(meta.VersionGA, "mock-project", "urlMaps", key) + } + + m.Objects[key] = &MockUrlMapsObj{obj} + glog.V(5).Infof("MockUrlMaps.Insert(%v, %v, %+v) = nil", ctx, key, obj) + return nil +} + +// Delete is a mock for deleting the object. +func (m *MockUrlMaps) Delete(ctx context.Context, key meta.Key) error { + if m.DeleteHook != nil { + if intercept, err := m.DeleteHook(m, ctx, key); intercept { + glog.V(5).Infof("MockUrlMaps.Delete(%v, %v) = %v", ctx, key, err) + return err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.DeleteError[key]; ok { + glog.V(5).Infof("MockUrlMaps.Delete(%v, %v) = %v", ctx, key, err) + return err + } + if _, ok := m.Objects[key]; !ok { + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockUrlMaps %v not found", key), + } + glog.V(5).Infof("MockUrlMaps.Delete(%v, %v) = %v", ctx, key, err) + return err + } + + delete(m.Objects, key) + glog.V(5).Infof("MockUrlMaps.Delete(%v, %v) = nil", ctx, key) + return nil +} + +// Obj wraps the object for use in the mock. +func (m *MockUrlMaps) Obj(o *ga.UrlMap) *MockUrlMapsObj { + return &MockUrlMapsObj{o} +} + +// Update is a mock for the corresponding method. +func (m *MockUrlMaps) Update(ctx context.Context, key meta.Key, arg0 *ga.UrlMap) error { + if m.UpdateHook != nil { + return m.UpdateHook(m, ctx, key, arg0) + } + return nil +} + +// GCEUrlMaps is a simplifying adapter for the GCE UrlMaps. +type GCEUrlMaps struct { + s *Service +} + +// Get the UrlMap named by key. +func (g *GCEUrlMaps) Get(ctx context.Context, key meta.Key) (*ga.UrlMap, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "UrlMaps") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "UrlMaps", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.UrlMaps.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all UrlMap objects. +func (g *GCEUrlMaps) List(ctx context.Context, fl *filter.F) ([]*ga.UrlMap, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "UrlMaps") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "UrlMaps", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.UrlMaps.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.UrlMap + f := func(l *ga.UrlMapList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} + +// Insert UrlMap with key of value obj. +func (g *GCEUrlMaps) Insert(ctx context.Context, key meta.Key, obj *ga.UrlMap) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "UrlMaps") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Insert", + Version: meta.Version("ga"), + Service: "UrlMaps", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + obj.Name = key.Name + call := g.s.GA.UrlMaps.Insert(projectID, obj) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Delete the UrlMap referenced by key. +func (g *GCEUrlMaps) Delete(ctx context.Context, key meta.Key) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "UrlMaps") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Delete", + Version: meta.Version("ga"), + Service: "UrlMaps", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.UrlMaps.Delete(projectID, key.Name) + + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Update is a method on GCEUrlMaps. +func (g *GCEUrlMaps) Update(ctx context.Context, key meta.Key, arg0 *ga.UrlMap) error { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "UrlMaps") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Update", + Version: meta.Version("ga"), + Service: "UrlMaps", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.UrlMaps.Update(projectID, key.Name, arg0) + call.Context(ctx) + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} + +// Zones is an interface that allows for mocking of Zones. +type Zones interface { + Get(ctx context.Context, key meta.Key) (*ga.Zone, error) + List(ctx context.Context, fl *filter.F) ([]*ga.Zone, error) +} + +// NewMockZones returns a new mock for Zones. +func NewMockZones(objs map[meta.Key]*MockZonesObj) *MockZones { + mock := &MockZones{ + Objects: objs, + GetError: map[meta.Key]error{}, + } + return mock +} + +// MockZones is the mock for Zones. +type MockZones struct { + Lock sync.Mutex + + // Objects maintained by the mock. + Objects map[meta.Key]*MockZonesObj + + // If an entry exists for the given key and operation, then the error + // will be returned instead of the operation. + GetError map[meta.Key]error + ListError *error + + // xxxHook allow you to intercept the standard processing of the mock in + // order to add your own logic. Return (true, _, _) to prevent the normal + // execution flow of the mock. Return (false, nil, nil) to continue with + // normal mock behavior/ after the hook function executes. + GetHook func(m *MockZones, ctx context.Context, key meta.Key) (bool, *ga.Zone, error) + ListHook func(m *MockZones, ctx context.Context, fl *filter.F) (bool, []*ga.Zone, error) + + // X is extra state that can be used as part of the mock. Generated code + // will not use this field. + X interface{} +} + +// Get returns the object from the mock. +func (m *MockZones) Get(ctx context.Context, key meta.Key) (*ga.Zone, error) { + if m.GetHook != nil { + if intercept, obj, err := m.GetHook(m, ctx, key); intercept { + glog.V(5).Infof("MockZones.Get(%v, %s) = %+v, %v", ctx, key, obj, err) + return obj, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if err, ok := m.GetError[key]; ok { + glog.V(5).Infof("MockZones.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err + } + if obj, ok := m.Objects[key]; ok { + typedObj := obj.ToGA() + glog.V(5).Infof("MockZones.Get(%v, %s) = %+v, nil", ctx, key, typedObj) + return typedObj, nil + } + + err := &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockZones %v not found", key), + } + glog.V(5).Infof("MockZones.Get(%v, %s) = nil, %v", ctx, key, err) + return nil, err +} + +// List all of the objects in the mock. +func (m *MockZones) List(ctx context.Context, fl *filter.F) ([]*ga.Zone, error) { + if m.ListHook != nil { + if intercept, objs, err := m.ListHook(m, ctx, fl); intercept { + glog.V(5).Infof("MockZones.List(%v, %v) = [%v items], %v", ctx, fl, len(objs), err) + return objs, err + } + } + + m.Lock.Lock() + defer m.Lock.Unlock() + + if m.ListError != nil { + err := *m.ListError + glog.V(5).Infof("MockZones.List(%v, %v) = nil, %v", ctx, fl, err) + + return nil, *m.ListError + } + + var objs []*ga.Zone + for _, obj := range m.Objects { + if !fl.Match(obj.ToGA()) { + continue + } + objs = append(objs, obj.ToGA()) + } + + glog.V(5).Infof("MockZones.List(%v, %v) = [%v items], nil", ctx, fl, len(objs)) + return objs, nil +} + +// Obj wraps the object for use in the mock. +func (m *MockZones) Obj(o *ga.Zone) *MockZonesObj { + return &MockZonesObj{o} +} + +// GCEZones is a simplifying adapter for the GCE Zones. +type GCEZones struct { + s *Service +} + +// Get the Zone named by key. +func (g *GCEZones) Get(ctx context.Context, key meta.Key) (*ga.Zone, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Zones") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Zones", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Zones.Get(projectID, key.Name) + call.Context(ctx) + return call.Do() +} + +// List all Zone objects. +func (g *GCEZones) List(ctx context.Context, fl *filter.F) ([]*ga.Zone, error) { + projectID := g.s.ProjectRouter.ProjectID(ctx, "ga", "Zones") + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "List", + Version: meta.Version("ga"), + Service: "Zones", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Zones.List(projectID) + if fl != filter.None { + call.Filter(fl.String()) + } + var all []*ga.Zone + f := func(l *ga.ZoneList) error { + all = append(all, l.Items...) + return nil + } + if err := call.Pages(ctx, f); err != nil { + return nil, err + } + return all, nil +} diff --git a/pkg/cloudprovider/providers/gce/cloud/gen_test.go b/pkg/cloudprovider/providers/gce/cloud/gen_test.go new file mode 100644 index 00000000000..cbe5d9938d3 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/gen_test.go @@ -0,0 +1,1749 @@ +/* +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. +*/ + +// This file was generated by "go run gen/main.go -mode test > gen_test.go". Do not edit +// directly. + +package cloud + +import ( + "context" + "reflect" + "testing" + + alpha "google.golang.org/api/compute/v0.alpha" + beta "google.golang.org/api/compute/v0.beta" + ga "google.golang.org/api/compute/v1" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/filter" + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" +) + +const location = "location" + +func TestDisksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.ZonalKey("key-alpha", "location") + key = keyAlpha + keyGA := meta.ZonalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaDisks().Get(ctx, *key); err == nil { + t.Errorf("AlphaDisks().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.Disks().Get(ctx, *key); err == nil { + t.Errorf("Disks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Disk{} + if err := mock.AlphaDisks().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaDisks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.Disk{} + if err := mock.Disks().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Disks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaDisks().Get(ctx, *key); err != nil { + t.Errorf("AlphaDisks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.Disks().Get(ctx, *key); err != nil { + t.Errorf("Disks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaDisks.Objects[*keyAlpha] = mock.MockAlphaDisks.Obj(&alpha.Disk{Name: keyAlpha.Name}) + mock.MockDisks.Objects[*keyGA] = mock.MockDisks.Obj(&ga.Disk{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaDisks().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaDisks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaDisks().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.Disks().List(ctx, location, filter.None) + if err != nil { + t.Errorf("Disks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaDisks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaDisks().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaDisks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.Disks().Delete(ctx, *keyGA); err != nil { + t.Errorf("Disks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaDisks().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaDisks().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.Disks().Delete(ctx, *keyGA); err == nil { + t.Errorf("Disks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestFirewallsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Firewalls().Get(ctx, *key); err == nil { + t.Errorf("Firewalls().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.Firewall{} + if err := mock.Firewalls().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Firewalls().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.Firewalls().Get(ctx, *key); err != nil { + t.Errorf("Firewalls().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockFirewalls.Objects[*keyGA] = mock.MockFirewalls.Obj(&ga.Firewall{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Firewalls().List(ctx, filter.None) + if err != nil { + t.Errorf("Firewalls().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaFirewalls().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.Firewalls().Delete(ctx, *keyGA); err != nil { + t.Errorf("Firewalls().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.Firewalls().Delete(ctx, *keyGA); err == nil { + t.Errorf("Firewalls().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestInstancesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.ZonalKey("key-alpha", "location") + key = keyAlpha + keyBeta := meta.ZonalKey("key-beta", "location") + key = keyBeta + keyGA := meta.ZonalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaInstances().Get(ctx, *key); err == nil { + t.Errorf("AlphaInstances().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BetaInstances().Get(ctx, *key); err == nil { + t.Errorf("BetaInstances().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.Instances().Get(ctx, *key); err == nil { + t.Errorf("Instances().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Instance{} + if err := mock.AlphaInstances().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &beta.Instance{} + if err := mock.BetaInstances().Insert(ctx, *keyBeta, obj); err != nil { + t.Errorf("BetaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.Instance{} + if err := mock.Instances().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Instances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaInstances().Get(ctx, *key); err != nil { + t.Errorf("AlphaInstances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BetaInstances().Get(ctx, *key); err != nil { + t.Errorf("BetaInstances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.Instances().Get(ctx, *key); err != nil { + t.Errorf("Instances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaInstances.Objects[*keyAlpha] = mock.MockAlphaInstances.Obj(&alpha.Instance{Name: keyAlpha.Name}) + mock.MockBetaInstances.Objects[*keyBeta] = mock.MockBetaInstances.Obj(&beta.Instance{Name: keyBeta.Name}) + mock.MockInstances.Objects[*keyGA] = mock.MockInstances.Obj(&ga.Instance{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-beta": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaInstances().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaInstances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BetaInstances().List(ctx, location, filter.None) + if err != nil { + t.Errorf("BetaInstances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.Instances().List(ctx, location, filter.None) + if err != nil { + t.Errorf("Instances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaInstances().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaInstances().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.BetaInstances().Delete(ctx, *keyBeta); err != nil { + t.Errorf("BetaInstances().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.Instances().Delete(ctx, *keyGA); err != nil { + t.Errorf("Instances().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaInstances().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaInstances().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.BetaInstances().Delete(ctx, *keyBeta); err == nil { + t.Errorf("BetaInstances().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.Instances().Delete(ctx, *keyGA); err == nil { + t.Errorf("Instances().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestProjectsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + + // Insert. + + // Get across versions. + + // List. + mock.MockProjects.Objects[*keyGA] = mock.MockProjects.Obj(&ga.Project{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + + // Delete across versions. + + // Delete not found. +} + +func TestRoutesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Routes().Get(ctx, *key); err == nil { + t.Errorf("Routes().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.Route{} + if err := mock.Routes().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Routes().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.Routes().Get(ctx, *key); err != nil { + t.Errorf("Routes().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockRoutes.Objects[*keyGA] = mock.MockRoutes.Obj(&ga.Route{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Routes().List(ctx, filter.None) + if err != nil { + t.Errorf("Routes().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRoutes().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.Routes().Delete(ctx, *keyGA); err != nil { + t.Errorf("Routes().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.Routes().Delete(ctx, *keyGA); err == nil { + t.Errorf("Routes().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestTargetPoolsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.RegionalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.TargetPools().Get(ctx, *key); err == nil { + t.Errorf("TargetPools().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.TargetPool{} + if err := mock.TargetPools().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("TargetPools().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.TargetPools().Get(ctx, *key); err != nil { + t.Errorf("TargetPools().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockTargetPools.Objects[*keyGA] = mock.MockTargetPools.Obj(&ga.TargetPool{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.TargetPools().List(ctx, location, filter.None) + if err != nil { + t.Errorf("TargetPools().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaTargetPools().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.TargetPools().Delete(ctx, *keyGA); err != nil { + t.Errorf("TargetPools().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.TargetPools().Delete(ctx, *keyGA); err == nil { + t.Errorf("TargetPools().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestGlobalForwardingRulesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.GlobalForwardingRules().Get(ctx, *key); err == nil { + t.Errorf("GlobalForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.ForwardingRule{} + if err := mock.GlobalForwardingRules().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("GlobalForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.GlobalForwardingRules().Get(ctx, *key); err != nil { + t.Errorf("GlobalForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockGlobalForwardingRules.Objects[*keyGA] = mock.MockGlobalForwardingRules.Obj(&ga.ForwardingRule{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.GlobalForwardingRules().List(ctx, filter.None) + if err != nil { + t.Errorf("GlobalForwardingRules().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaGlobalForwardingRules().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.GlobalForwardingRules().Delete(ctx, *keyGA); err != nil { + t.Errorf("GlobalForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.GlobalForwardingRules().Delete(ctx, *keyGA); err == nil { + t.Errorf("GlobalForwardingRules().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestNetworkEndpointGroupsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.ZonalKey("key-alpha", "location") + key = keyAlpha + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaNetworkEndpointGroups().Get(ctx, *key); err == nil { + t.Errorf("AlphaNetworkEndpointGroups().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.NetworkEndpointGroup{} + if err := mock.AlphaNetworkEndpointGroups().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaNetworkEndpointGroups().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaNetworkEndpointGroups().Get(ctx, *key); err != nil { + t.Errorf("AlphaNetworkEndpointGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaNetworkEndpointGroups.Objects[*keyAlpha] = mock.MockAlphaNetworkEndpointGroups.Obj(&alpha.NetworkEndpointGroup{Name: keyAlpha.Name}) + want := map[string]bool{ + "key-alpha": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaNetworkEndpointGroups().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaNetworkEndpointGroups().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaNetworkEndpointGroups().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestTargetHttpProxiesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.TargetHttpProxies().Get(ctx, *key); err == nil { + t.Errorf("TargetHttpProxies().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.TargetHttpProxy{} + if err := mock.TargetHttpProxies().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("TargetHttpProxies().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.TargetHttpProxies().Get(ctx, *key); err != nil { + t.Errorf("TargetHttpProxies().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockTargetHttpProxies.Objects[*keyGA] = mock.MockTargetHttpProxies.Obj(&ga.TargetHttpProxy{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.TargetHttpProxies().List(ctx, filter.None) + if err != nil { + t.Errorf("TargetHttpProxies().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaTargetHttpProxies().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.TargetHttpProxies().Delete(ctx, *keyGA); err != nil { + t.Errorf("TargetHttpProxies().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.TargetHttpProxies().Delete(ctx, *keyGA); err == nil { + t.Errorf("TargetHttpProxies().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestUrlMapsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.UrlMaps().Get(ctx, *key); err == nil { + t.Errorf("UrlMaps().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.UrlMap{} + if err := mock.UrlMaps().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("UrlMaps().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.UrlMaps().Get(ctx, *key); err != nil { + t.Errorf("UrlMaps().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockUrlMaps.Objects[*keyGA] = mock.MockUrlMaps.Obj(&ga.UrlMap{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.UrlMaps().List(ctx, filter.None) + if err != nil { + t.Errorf("UrlMaps().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaUrlMaps().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.UrlMaps().Delete(ctx, *keyGA); err != nil { + t.Errorf("UrlMaps().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.UrlMaps().Delete(ctx, *keyGA); err == nil { + t.Errorf("UrlMaps().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestZonesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Zones().Get(ctx, *key); err == nil { + t.Errorf("Zones().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + + // Get across versions. + + // List. + mock.MockZones.Objects[*keyGA] = mock.MockZones.Obj(&ga.Zone{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Zones().List(ctx, filter.None) + if err != nil { + t.Errorf("Zones().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaZones().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + + // Delete not found. +} + +func TestGlobalAddressesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.GlobalAddresses().Get(ctx, *key); err == nil { + t.Errorf("GlobalAddresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.Address{} + if err := mock.GlobalAddresses().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("GlobalAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.GlobalAddresses().Get(ctx, *key); err != nil { + t.Errorf("GlobalAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockGlobalAddresses.Objects[*keyGA] = mock.MockGlobalAddresses.Obj(&ga.Address{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.GlobalAddresses().List(ctx, filter.None) + if err != nil { + t.Errorf("GlobalAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaGlobalAddresses().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.GlobalAddresses().Delete(ctx, *keyGA); err != nil { + t.Errorf("GlobalAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.GlobalAddresses().Delete(ctx, *keyGA); err == nil { + t.Errorf("GlobalAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestBackendServicesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.GlobalKey("key-alpha") + key = keyAlpha + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaBackendServices().Get(ctx, *key); err == nil { + t.Errorf("AlphaBackendServices().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BackendServices().Get(ctx, *key); err == nil { + t.Errorf("BackendServices().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.BackendService{} + if err := mock.AlphaBackendServices().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.BackendService{} + if err := mock.BackendServices().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("BackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaBackendServices().Get(ctx, *key); err != nil { + t.Errorf("AlphaBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BackendServices().Get(ctx, *key); err != nil { + t.Errorf("BackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaBackendServices.Objects[*keyAlpha] = mock.MockAlphaBackendServices.Obj(&alpha.BackendService{Name: keyAlpha.Name}) + mock.MockBackendServices.Objects[*keyGA] = mock.MockBackendServices.Obj(&ga.BackendService{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaBackendServices().List(ctx, filter.None) + if err != nil { + t.Errorf("AlphaBackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaBackendServices().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BackendServices().List(ctx, filter.None) + if err != nil { + t.Errorf("BackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaBackendServices().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaBackendServices().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaBackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.BackendServices().Delete(ctx, *keyGA); err != nil { + t.Errorf("BackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaBackendServices().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaBackendServices().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.BackendServices().Delete(ctx, *keyGA); err == nil { + t.Errorf("BackendServices().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestForwardingRulesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + keyGA := meta.RegionalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaForwardingRules().Get(ctx, *key); err == nil { + t.Errorf("AlphaForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.ForwardingRules().Get(ctx, *key); err == nil { + t.Errorf("ForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.ForwardingRule{} + if err := mock.AlphaForwardingRules().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.ForwardingRule{} + if err := mock.ForwardingRules().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("ForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaForwardingRules().Get(ctx, *key); err != nil { + t.Errorf("AlphaForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.ForwardingRules().Get(ctx, *key); err != nil { + t.Errorf("ForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaForwardingRules.Objects[*keyAlpha] = mock.MockAlphaForwardingRules.Obj(&alpha.ForwardingRule{Name: keyAlpha.Name}) + mock.MockForwardingRules.Objects[*keyGA] = mock.MockForwardingRules.Obj(&ga.ForwardingRule{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaForwardingRules().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaForwardingRules().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaForwardingRules().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.ForwardingRules().List(ctx, location, filter.None) + if err != nil { + t.Errorf("ForwardingRules().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaForwardingRules().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaForwardingRules().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.ForwardingRules().Delete(ctx, *keyGA); err != nil { + t.Errorf("ForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaForwardingRules().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaForwardingRules().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.ForwardingRules().Delete(ctx, *keyGA); err == nil { + t.Errorf("ForwardingRules().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestRegionsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Regions().Get(ctx, *key); err == nil { + t.Errorf("Regions().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + + // Get across versions. + + // List. + mock.MockRegions.Objects[*keyGA] = mock.MockRegions.Obj(&ga.Region{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Regions().List(ctx, filter.None) + if err != nil { + t.Errorf("Regions().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRegions().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + + // Delete not found. +} + +func TestAddressesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + keyBeta := meta.RegionalKey("key-beta", "location") + key = keyBeta + keyGA := meta.RegionalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaAddresses().Get(ctx, *key); err == nil { + t.Errorf("AlphaAddresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BetaAddresses().Get(ctx, *key); err == nil { + t.Errorf("BetaAddresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.Addresses().Get(ctx, *key); err == nil { + t.Errorf("Addresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Address{} + if err := mock.AlphaAddresses().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &beta.Address{} + if err := mock.BetaAddresses().Insert(ctx, *keyBeta, obj); err != nil { + t.Errorf("BetaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.Address{} + if err := mock.Addresses().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Addresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaAddresses().Get(ctx, *key); err != nil { + t.Errorf("AlphaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BetaAddresses().Get(ctx, *key); err != nil { + t.Errorf("BetaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.Addresses().Get(ctx, *key); err != nil { + t.Errorf("Addresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaAddresses.Objects[*keyAlpha] = mock.MockAlphaAddresses.Obj(&alpha.Address{Name: keyAlpha.Name}) + mock.MockBetaAddresses.Objects[*keyBeta] = mock.MockBetaAddresses.Obj(&beta.Address{Name: keyBeta.Name}) + mock.MockAddresses.Objects[*keyGA] = mock.MockAddresses.Obj(&ga.Address{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-beta": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaAddresses().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BetaAddresses().List(ctx, location, filter.None) + if err != nil { + t.Errorf("BetaAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.Addresses().List(ctx, location, filter.None) + if err != nil { + t.Errorf("Addresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err != nil { + t.Errorf("BetaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.Addresses().Delete(ctx, *keyGA); err != nil { + t.Errorf("Addresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err == nil { + t.Errorf("BetaAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.Addresses().Delete(ctx, *keyGA); err == nil { + t.Errorf("Addresses().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestRegionBackendServicesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaRegionBackendServices().Get(ctx, *key); err == nil { + t.Errorf("AlphaRegionBackendServices().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.BackendService{} + if err := mock.AlphaRegionBackendServices().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaRegionBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaRegionBackendServices().Get(ctx, *key); err != nil { + t.Errorf("AlphaRegionBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaRegionBackendServices.Objects[*keyAlpha] = mock.MockAlphaRegionBackendServices.Obj(&alpha.BackendService{Name: keyAlpha.Name}) + want := map[string]bool{ + "key-alpha": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaRegionBackendServices().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaRegionBackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRegionBackendServices().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaRegionBackendServices().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaRegionBackendServices().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestRegionDisksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaRegionDisks().Get(ctx, *key); err == nil { + t.Errorf("AlphaRegionDisks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Disk{} + if err := mock.AlphaRegionDisks().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaRegionDisks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaRegionDisks().Get(ctx, *key); err != nil { + t.Errorf("AlphaRegionDisks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaRegionDisks.Objects[*keyAlpha] = mock.MockAlphaRegionDisks.Obj(&alpha.Disk{Name: keyAlpha.Name}) + want := map[string]bool{ + "key-alpha": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaRegionDisks().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaRegionDisks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRegionDisks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaRegionDisks().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaRegionDisks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaRegionDisks().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaRegionDisks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestHealthChecksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.GlobalKey("key-alpha") + key = keyAlpha + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaHealthChecks().Get(ctx, *key); err == nil { + t.Errorf("AlphaHealthChecks().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.HealthChecks().Get(ctx, *key); err == nil { + t.Errorf("HealthChecks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.HealthCheck{} + if err := mock.AlphaHealthChecks().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.HealthCheck{} + if err := mock.HealthChecks().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("HealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaHealthChecks().Get(ctx, *key); err != nil { + t.Errorf("AlphaHealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.HealthChecks().Get(ctx, *key); err != nil { + t.Errorf("HealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaHealthChecks.Objects[*keyAlpha] = mock.MockAlphaHealthChecks.Obj(&alpha.HealthCheck{Name: keyAlpha.Name}) + mock.MockHealthChecks.Objects[*keyGA] = mock.MockHealthChecks.Obj(&ga.HealthCheck{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaHealthChecks().List(ctx, filter.None) + if err != nil { + t.Errorf("AlphaHealthChecks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaHealthChecks().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.HealthChecks().List(ctx, filter.None) + if err != nil { + t.Errorf("HealthChecks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaHealthChecks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaHealthChecks().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaHealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.HealthChecks().Delete(ctx, *keyGA); err != nil { + t.Errorf("HealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaHealthChecks().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaHealthChecks().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.HealthChecks().Delete(ctx, *keyGA); err == nil { + t.Errorf("HealthChecks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestHttpHealthChecksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.HttpHealthChecks().Get(ctx, *key); err == nil { + t.Errorf("HttpHealthChecks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.HttpHealthCheck{} + if err := mock.HttpHealthChecks().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("HttpHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.HttpHealthChecks().Get(ctx, *key); err != nil { + t.Errorf("HttpHealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockHttpHealthChecks.Objects[*keyGA] = mock.MockHttpHealthChecks.Obj(&ga.HttpHealthCheck{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.HttpHealthChecks().List(ctx, filter.None) + if err != nil { + t.Errorf("HttpHealthChecks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaHttpHealthChecks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.HttpHealthChecks().Delete(ctx, *keyGA); err != nil { + t.Errorf("HttpHealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.HttpHealthChecks().Delete(ctx, *keyGA); err == nil { + t.Errorf("HttpHealthChecks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestHttpsHealthChecksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.HttpsHealthChecks().Get(ctx, *key); err == nil { + t.Errorf("HttpsHealthChecks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.HttpsHealthCheck{} + if err := mock.HttpsHealthChecks().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("HttpsHealthChecks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.HttpsHealthChecks().Get(ctx, *key); err != nil { + t.Errorf("HttpsHealthChecks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockHttpsHealthChecks.Objects[*keyGA] = mock.MockHttpsHealthChecks.Obj(&ga.HttpsHealthCheck{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.HttpsHealthChecks().List(ctx, filter.None) + if err != nil { + t.Errorf("HttpsHealthChecks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaHttpsHealthChecks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.HttpsHealthChecks().Delete(ctx, *keyGA); err != nil { + t.Errorf("HttpsHealthChecks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.HttpsHealthChecks().Delete(ctx, *keyGA); err == nil { + t.Errorf("HttpsHealthChecks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestInstanceGroupsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.ZonalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.InstanceGroups().Get(ctx, *key); err == nil { + t.Errorf("InstanceGroups().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.InstanceGroup{} + if err := mock.InstanceGroups().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("InstanceGroups().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.InstanceGroups().Get(ctx, *key); err != nil { + t.Errorf("InstanceGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockInstanceGroups.Objects[*keyGA] = mock.MockInstanceGroups.Obj(&ga.InstanceGroup{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.InstanceGroups().List(ctx, location, filter.None) + if err != nil { + t.Errorf("InstanceGroups().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstanceGroups().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.InstanceGroups().Delete(ctx, *keyGA); err != nil { + t.Errorf("InstanceGroups().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.InstanceGroups().Delete(ctx, *keyGA); err == nil { + t.Errorf("InstanceGroups().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestSslCertificatesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.SslCertificates().Get(ctx, *key); err == nil { + t.Errorf("SslCertificates().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.SslCertificate{} + if err := mock.SslCertificates().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("SslCertificates().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.SslCertificates().Get(ctx, *key); err != nil { + t.Errorf("SslCertificates().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockSslCertificates.Objects[*keyGA] = mock.MockSslCertificates.Obj(&ga.SslCertificate{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.SslCertificates().List(ctx, filter.None) + if err != nil { + t.Errorf("SslCertificates().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaSslCertificates().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.SslCertificates().Delete(ctx, *keyGA); err != nil { + t.Errorf("SslCertificates().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.SslCertificates().Delete(ctx, *keyGA); err == nil { + t.Errorf("SslCertificates().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestTargetHttpsProxiesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.TargetHttpsProxies().Get(ctx, *key); err == nil { + t.Errorf("TargetHttpsProxies().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.TargetHttpsProxy{} + if err := mock.TargetHttpsProxies().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("TargetHttpsProxies().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.TargetHttpsProxies().Get(ctx, *key); err != nil { + t.Errorf("TargetHttpsProxies().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockTargetHttpsProxies.Objects[*keyGA] = mock.MockTargetHttpsProxies.Obj(&ga.TargetHttpsProxy{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.TargetHttpsProxies().List(ctx, filter.None) + if err != nil { + t.Errorf("TargetHttpsProxies().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaTargetHttpsProxies().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.TargetHttpsProxies().Delete(ctx, *keyGA); err != nil { + t.Errorf("TargetHttpsProxies().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.TargetHttpsProxies().Delete(ctx, *keyGA); err == nil { + t.Errorf("TargetHttpsProxies().Delete(%v, %v) = nil; want error", ctx, key) + } +} From a0adc1bb19c706ac5d93519c1fa68689c7782720 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:36:12 -0800 Subject: [PATCH 09/18] Special custom code for handling the Projects resource --- .../providers/gce/cloud/gce_projects.go | 95 +++++++++++++++++++ 1 file changed, 95 insertions(+) create mode 100644 pkg/cloudprovider/providers/gce/cloud/gce_projects.go diff --git a/pkg/cloudprovider/providers/gce/cloud/gce_projects.go b/pkg/cloudprovider/providers/gce/cloud/gce_projects.go new file mode 100644 index 00000000000..adc60927afc --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/gce_projects.go @@ -0,0 +1,95 @@ +/* +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 cloud + +import ( + "context" + "fmt" + "net/http" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" + compute "google.golang.org/api/compute/v1" + "google.golang.org/api/googleapi" +) + +// ProjectsOps is the manually implemented methods for the Projects service. +type ProjectsOps interface { + Get(ctx context.Context, projectID string) (*compute.Project, error) + SetCommonInstanceMetadata(ctx context.Context, projectID string, m *compute.Metadata) error +} + +// MockProjectOpsState is stored in the mock.X field. +type MockProjectOpsState struct { + metadata map[string]*compute.Metadata +} + +func (m *MockProjects) Get(ctx context.Context, projectID string) (*compute.Project, error) { + m.Lock.Lock() + defer m.Lock.Unlock() + + if p, ok := m.Objects[*meta.GlobalKey(projectID)]; ok { + return p.ToGA(), nil + } + return nil, &googleapi.Error{ + Code: http.StatusNotFound, + Message: fmt.Sprintf("MockProjects %v not found", projectID), + } +} + +func (g *GCEProjects) Get(ctx context.Context, projectID string) (*compute.Project, error) { + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "Get", + Version: meta.Version("ga"), + Service: "Projects", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return nil, err + } + call := g.s.GA.Projects.Get(projectID) + call.Context(ctx) + return call.Do() +} + +func (m *MockProjects) SetCommonInstanceMetadata(ctx context.Context, projectID string, meta *compute.Metadata) error { + if m.X == nil { + m.X = &MockProjectOpsState{metadata: map[string]*compute.Metadata{}} + } + state := m.X.(*MockProjectOpsState) + state.metadata[projectID] = meta + return nil +} + +func (g *GCEProjects) SetCommonInstanceMetadata(ctx context.Context, projectID string, m *compute.Metadata) error { + rk := &RateLimitKey{ + ProjectID: projectID, + Operation: "SetCommonInstanceMetadata", + Version: meta.Version("ga"), + Service: "Projects", + } + if err := g.s.RateLimiter.Accept(ctx, rk); err != nil { + return err + } + call := g.s.GA.Projects.SetCommonInstanceMetadata(projectID, m) + call.Context(ctx) + + op, err := call.Do() + if err != nil { + return err + } + return g.s.WaitForCompletion(ctx, op) +} From f076f4fa0b0418ee0c99102a9021f1e4b8978b34 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:36:28 -0800 Subject: [PATCH 10/18] Hand written unit test for exercising the mock --- .../providers/gce/cloud/mock_test.go | 150 ++++++++++++++++++ 1 file changed, 150 insertions(+) create mode 100644 pkg/cloudprovider/providers/gce/cloud/mock_test.go diff --git a/pkg/cloudprovider/providers/gce/cloud/mock_test.go b/pkg/cloudprovider/providers/gce/cloud/mock_test.go new file mode 100644 index 00000000000..3d0fb160cc0 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/mock_test.go @@ -0,0 +1,150 @@ +/* +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 cloud + +import ( + "context" + "reflect" + "testing" + + alpha "google.golang.org/api/compute/v0.alpha" + beta "google.golang.org/api/compute/v0.beta" + ga "google.golang.org/api/compute/v1" + + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/filter" + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" +) + +func TestMocks(t *testing.T) { + t.Parallel() + + // This test uses Addresses, but the logic that is generated is the same for + // other basic objects. + const region = "us-central1" + + ctx := context.Background() + mock := NewMockGCE() + + keyAlpha := meta.RegionalKey("key-alpha", region) + keyBeta := meta.RegionalKey("key-beta", region) + keyGA := meta.RegionalKey("key-ga", region) + key := keyAlpha + + // Get not found. + if _, err := mock.AlphaAddresses().Get(ctx, *key); err == nil { + t.Errorf("AlphaAddresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BetaAddresses().Get(ctx, *key); err == nil { + t.Errorf("BetaAddresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.Addresses().Get(ctx, *key); err == nil { + t.Errorf("Addresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + // Insert. + { + obj := &alpha.Address{} + if err := mock.AlphaAddresses().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &beta.Address{} + if err := mock.BetaAddresses().Insert(ctx, *keyBeta, obj); err != nil { + t.Errorf("BetaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.Address{} + if err := mock.Addresses().Insert(ctx, *keyGA, &ga.Address{Name: "ga"}); err != nil { + t.Errorf("Addresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + // Get across versions. + if obj, err := mock.AlphaAddresses().Get(ctx, *key); err != nil { + t.Errorf("AlphaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BetaAddresses().Get(ctx, *key); err != nil { + t.Errorf("BetaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.Addresses().Get(ctx, *key); err != nil { + t.Errorf("Addresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + // List across versions. + want := map[string]bool{"key-alpha": true, "key-beta": true, "key-ga": true} + { + objs, err := mock.AlphaAddresses().List(ctx, region, filter.None) + if err != nil { + t.Errorf("AlphaAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, region, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BetaAddresses().List(ctx, region, filter.None) + if err != nil { + t.Errorf("BetaAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, region, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.Addresses().List(ctx, region, filter.None) + if err != nil { + t.Errorf("Addresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, region, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + // Delete across versions. + if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err != nil { + t.Errorf("BetaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.Addresses().Delete(ctx, *keyGA); err != nil { + t.Errorf("Addresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + // Delete not found. + if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err == nil { + t.Errorf("BetaAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.Addresses().Delete(ctx, *keyGA); err == nil { + t.Errorf("Addresses().Delete(%v, %v) = nil; want error", ctx, key) + } +} From 9a7088555904a3f3a9f61d94292fd8f308563602 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Thu, 4 Jan 2018 23:30:56 -0800 Subject: [PATCH 11/18] BUILD --- pkg/cloudprovider/providers/gce/BUILD | 5 +- pkg/cloudprovider/providers/gce/cloud/BUILD | 63 +++++++++++++++++++ .../providers/gce/cloud/filter/BUILD | 30 +++++++++ .../providers/gce/cloud/gen/BUILD | 33 ++++++++++ .../providers/gce/cloud/meta/BUILD | 41 ++++++++++++ 5 files changed, 171 insertions(+), 1 deletion(-) create mode 100644 pkg/cloudprovider/providers/gce/cloud/BUILD create mode 100644 pkg/cloudprovider/providers/gce/cloud/filter/BUILD create mode 100644 pkg/cloudprovider/providers/gce/cloud/gen/BUILD create mode 100644 pkg/cloudprovider/providers/gce/cloud/meta/BUILD diff --git a/pkg/cloudprovider/providers/gce/BUILD b/pkg/cloudprovider/providers/gce/BUILD index 18205b9fcad..b112c95912c 100644 --- a/pkg/cloudprovider/providers/gce/BUILD +++ b/pkg/cloudprovider/providers/gce/BUILD @@ -125,6 +125,9 @@ filegroup( filegroup( name = "all-srcs", - srcs = [":package-srcs"], + srcs = [ + ":package-srcs", + "//pkg/cloudprovider/providers/gce/cloud:all-srcs", + ], tags = ["automanaged"], ) diff --git a/pkg/cloudprovider/providers/gce/cloud/BUILD b/pkg/cloudprovider/providers/gce/cloud/BUILD new file mode 100644 index 00000000000..3df8f7a5e97 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/BUILD @@ -0,0 +1,63 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") + +go_library( + name = "go_default_library", + srcs = [ + "doc.go", + "gce_projects.go", + "gen.go", + "op.go", + "project.go", + "ratelimit.go", + "service.go", + "utils.go", + ], + importpath = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud", + visibility = ["//visibility:public"], + deps = [ + "//pkg/cloudprovider/providers/gce/cloud/filter:go_default_library", + "//pkg/cloudprovider/providers/gce/cloud/meta:go_default_library", + "//vendor/github.com/golang/glog:go_default_library", + "//vendor/google.golang.org/api/compute/v0.alpha:go_default_library", + "//vendor/google.golang.org/api/compute/v0.beta:go_default_library", + "//vendor/google.golang.org/api/compute/v1:go_default_library", + "//vendor/google.golang.org/api/googleapi:go_default_library", + ], +) + +go_test( + name = "go_default_test", + srcs = [ + "gen_test.go", + "mock_test.go", + "utils_test.go", + ], + embed = [":go_default_library"], + importpath = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud", + deps = [ + "//pkg/cloudprovider/providers/gce/cloud/filter:go_default_library", + "//pkg/cloudprovider/providers/gce/cloud/meta:go_default_library", + "//vendor/google.golang.org/api/compute/v0.alpha:go_default_library", + "//vendor/google.golang.org/api/compute/v0.beta:go_default_library", + "//vendor/google.golang.org/api/compute/v1:go_default_library", + ], +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [ + ":package-srcs", + "//pkg/cloudprovider/providers/gce/cloud/filter:all-srcs", + "//pkg/cloudprovider/providers/gce/cloud/gen:all-srcs", + "//pkg/cloudprovider/providers/gce/cloud/meta:all-srcs", + ], + tags = ["automanaged"], + visibility = ["//visibility:public"], +) diff --git a/pkg/cloudprovider/providers/gce/cloud/filter/BUILD b/pkg/cloudprovider/providers/gce/cloud/filter/BUILD new file mode 100644 index 00000000000..c0176ded894 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/filter/BUILD @@ -0,0 +1,30 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") + +go_library( + name = "go_default_library", + srcs = ["filter.go"], + importpath = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/filter", + visibility = ["//visibility:public"], + deps = ["//vendor/github.com/golang/glog:go_default_library"], +) + +go_test( + name = "go_default_test", + srcs = ["filter_test.go"], + embed = [":go_default_library"], + importpath = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/filter", +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [":package-srcs"], + tags = ["automanaged"], + visibility = ["//visibility:public"], +) diff --git a/pkg/cloudprovider/providers/gce/cloud/gen/BUILD b/pkg/cloudprovider/providers/gce/cloud/gen/BUILD new file mode 100644 index 00000000000..e196daf2ac8 --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/gen/BUILD @@ -0,0 +1,33 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library") + +go_library( + name = "go_default_library", + srcs = ["main.go"], + importpath = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/gen", + visibility = ["//visibility:private"], + deps = [ + "//pkg/cloudprovider/providers/gce/cloud/meta:go_default_library", + "//vendor/github.com/golang/glog:go_default_library", + ], +) + +go_binary( + name = "gen", + embed = [":go_default_library"], + importpath = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/gen", + visibility = ["//visibility:public"], +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [":package-srcs"], + tags = ["automanaged"], + visibility = ["//visibility:public"], +) diff --git a/pkg/cloudprovider/providers/gce/cloud/meta/BUILD b/pkg/cloudprovider/providers/gce/cloud/meta/BUILD new file mode 100644 index 00000000000..4bcf3b5f5ba --- /dev/null +++ b/pkg/cloudprovider/providers/gce/cloud/meta/BUILD @@ -0,0 +1,41 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test") + +go_library( + name = "go_default_library", + srcs = [ + "doc.go", + "key.go", + "meta.go", + "method.go", + "service.go", + ], + importpath = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta", + visibility = ["//visibility:public"], + deps = [ + "//vendor/github.com/golang/glog:go_default_library", + "//vendor/google.golang.org/api/compute/v0.alpha:go_default_library", + "//vendor/google.golang.org/api/compute/v0.beta:go_default_library", + "//vendor/google.golang.org/api/compute/v1:go_default_library", + ], +) + +go_test( + name = "go_default_test", + srcs = ["key_test.go"], + embed = [":go_default_library"], + importpath = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta", +) + +filegroup( + name = "package-srcs", + srcs = glob(["**"]), + tags = ["automanaged"], + visibility = ["//visibility:private"], +) + +filegroup( + name = "all-srcs", + srcs = [":package-srcs"], + tags = ["automanaged"], + visibility = ["//visibility:public"], +) From 2aaf8b47b2bea38aa9f0c6082a087fd80960a272 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Fri, 5 Jan 2018 11:54:42 -0800 Subject: [PATCH 12/18] Clean up documentation. --- pkg/cloudprovider/providers/gce/cloud/doc.go | 1 + .../providers/gce/cloud/gce_projects.go | 6 +- pkg/cloudprovider/providers/gce/cloud/gen.go | 95 +++++++++++++++++++ .../providers/gce/cloud/gen/main.go | 4 +- .../providers/gce/cloud/meta/method.go | 11 ++- .../providers/gce/cloud/meta/service.go | 4 + .../providers/gce/cloud/project.go | 1 + .../providers/gce/cloud/ratelimit.go | 1 + 8 files changed, 120 insertions(+), 3 deletions(-) diff --git a/pkg/cloudprovider/providers/gce/cloud/doc.go b/pkg/cloudprovider/providers/gce/cloud/doc.go index d0d7a6cfb19..a6b121457cd 100644 --- a/pkg/cloudprovider/providers/gce/cloud/doc.go +++ b/pkg/cloudprovider/providers/gce/cloud/doc.go @@ -60,6 +60,7 @@ limitations under the License. // &ServiceInfo{ // Object: "InstanceGroup", // Name of the object type. // Service: "InstanceGroups", // Name of the service. +// Resource: "instanceGroups", // Lowercase resource name (as appears in the URL). // version: meta.VersionAlpha, // API version (one entry per version is needed). // keyType: Zonal, // What kind of resource this is. // serviceType: reflect.TypeOf(&alpha.InstanceGroupsService{}), // Associated golang type. diff --git a/pkg/cloudprovider/providers/gce/cloud/gce_projects.go b/pkg/cloudprovider/providers/gce/cloud/gce_projects.go index adc60927afc..c531881a94a 100644 --- a/pkg/cloudprovider/providers/gce/cloud/gce_projects.go +++ b/pkg/cloudprovider/providers/gce/cloud/gce_projects.go @@ -21,9 +21,9 @@ import ( "fmt" "net/http" - "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" compute "google.golang.org/api/compute/v1" "google.golang.org/api/googleapi" + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" ) // ProjectsOps is the manually implemented methods for the Projects service. @@ -37,6 +37,7 @@ type MockProjectOpsState struct { metadata map[string]*compute.Metadata } +// Get a project by projectID. func (m *MockProjects) Get(ctx context.Context, projectID string) (*compute.Project, error) { m.Lock.Lock() defer m.Lock.Unlock() @@ -50,6 +51,7 @@ func (m *MockProjects) Get(ctx context.Context, projectID string) (*compute.Proj } } +// Get a project by projectID. func (g *GCEProjects) Get(ctx context.Context, projectID string) (*compute.Project, error) { rk := &RateLimitKey{ ProjectID: projectID, @@ -65,6 +67,7 @@ func (g *GCEProjects) Get(ctx context.Context, projectID string) (*compute.Proje return call.Do() } +// SetCommonInstanceMetadata for a given project. func (m *MockProjects) SetCommonInstanceMetadata(ctx context.Context, projectID string, meta *compute.Metadata) error { if m.X == nil { m.X = &MockProjectOpsState{metadata: map[string]*compute.Metadata{}} @@ -74,6 +77,7 @@ func (m *MockProjects) SetCommonInstanceMetadata(ctx context.Context, projectID return nil } +// SetCommonInstanceMetadata for a given project. func (g *GCEProjects) SetCommonInstanceMetadata(ctx context.Context, projectID string, m *compute.Metadata) error { rk := &RateLimitKey{ ProjectID: projectID, diff --git a/pkg/cloudprovider/providers/gce/cloud/gen.go b/pkg/cloudprovider/providers/gce/cloud/gen.go index ef7a2c62eaf..33a2b7ba619 100644 --- a/pkg/cloudprovider/providers/gce/cloud/gen.go +++ b/pkg/cloudprovider/providers/gce/cloud/gen.go @@ -150,99 +150,162 @@ type GCE struct { gceZones *GCEZones } +// Addresses returns the interface for the ga Addresses. func (gce *GCE) Addresses() Addresses { return gce.gceAddresses } + +// AlphaAddresses returns the interface for the alpha Addresses. func (gce *GCE) AlphaAddresses() AlphaAddresses { return gce.gceAlphaAddresses } + +// BetaAddresses returns the interface for the beta Addresses. func (gce *GCE) BetaAddresses() BetaAddresses { return gce.gceBetaAddresses } + +// GlobalAddresses returns the interface for the ga GlobalAddresses. func (gce *GCE) GlobalAddresses() GlobalAddresses { return gce.gceGlobalAddresses } + +// BackendServices returns the interface for the ga BackendServices. func (gce *GCE) BackendServices() BackendServices { return gce.gceBackendServices } + +// AlphaBackendServices returns the interface for the alpha BackendServices. func (gce *GCE) AlphaBackendServices() AlphaBackendServices { return gce.gceAlphaBackendServices } + +// AlphaRegionBackendServices returns the interface for the alpha RegionBackendServices. func (gce *GCE) AlphaRegionBackendServices() AlphaRegionBackendServices { return gce.gceAlphaRegionBackendServices } + +// Disks returns the interface for the ga Disks. func (gce *GCE) Disks() Disks { return gce.gceDisks } + +// AlphaDisks returns the interface for the alpha Disks. func (gce *GCE) AlphaDisks() AlphaDisks { return gce.gceAlphaDisks } + +// AlphaRegionDisks returns the interface for the alpha RegionDisks. func (gce *GCE) AlphaRegionDisks() AlphaRegionDisks { return gce.gceAlphaRegionDisks } + +// Firewalls returns the interface for the ga Firewalls. func (gce *GCE) Firewalls() Firewalls { return gce.gceFirewalls } + +// ForwardingRules returns the interface for the ga ForwardingRules. func (gce *GCE) ForwardingRules() ForwardingRules { return gce.gceForwardingRules } + +// AlphaForwardingRules returns the interface for the alpha ForwardingRules. func (gce *GCE) AlphaForwardingRules() AlphaForwardingRules { return gce.gceAlphaForwardingRules } + +// GlobalForwardingRules returns the interface for the ga GlobalForwardingRules. func (gce *GCE) GlobalForwardingRules() GlobalForwardingRules { return gce.gceGlobalForwardingRules } + +// HealthChecks returns the interface for the ga HealthChecks. func (gce *GCE) HealthChecks() HealthChecks { return gce.gceHealthChecks } + +// AlphaHealthChecks returns the interface for the alpha HealthChecks. func (gce *GCE) AlphaHealthChecks() AlphaHealthChecks { return gce.gceAlphaHealthChecks } + +// HttpHealthChecks returns the interface for the ga HttpHealthChecks. func (gce *GCE) HttpHealthChecks() HttpHealthChecks { return gce.gceHttpHealthChecks } + +// HttpsHealthChecks returns the interface for the ga HttpsHealthChecks. func (gce *GCE) HttpsHealthChecks() HttpsHealthChecks { return gce.gceHttpsHealthChecks } + +// InstanceGroups returns the interface for the ga InstanceGroups. func (gce *GCE) InstanceGroups() InstanceGroups { return gce.gceInstanceGroups } + +// Instances returns the interface for the ga Instances. func (gce *GCE) Instances() Instances { return gce.gceInstances } + +// BetaInstances returns the interface for the beta Instances. func (gce *GCE) BetaInstances() BetaInstances { return gce.gceBetaInstances } + +// AlphaInstances returns the interface for the alpha Instances. func (gce *GCE) AlphaInstances() AlphaInstances { return gce.gceAlphaInstances } + +// AlphaNetworkEndpointGroups returns the interface for the alpha NetworkEndpointGroups. func (gce *GCE) AlphaNetworkEndpointGroups() AlphaNetworkEndpointGroups { return gce.gceAlphaNetworkEndpointGroups } + +// Projects returns the interface for the ga Projects. func (gce *GCE) Projects() Projects { return gce.gceProjects } + +// Regions returns the interface for the ga Regions. func (gce *GCE) Regions() Regions { return gce.gceRegions } + +// Routes returns the interface for the ga Routes. func (gce *GCE) Routes() Routes { return gce.gceRoutes } + +// SslCertificates returns the interface for the ga SslCertificates. func (gce *GCE) SslCertificates() SslCertificates { return gce.gceSslCertificates } + +// TargetHttpProxies returns the interface for the ga TargetHttpProxies. func (gce *GCE) TargetHttpProxies() TargetHttpProxies { return gce.gceTargetHttpProxies } + +// TargetHttpsProxies returns the interface for the ga TargetHttpsProxies. func (gce *GCE) TargetHttpsProxies() TargetHttpsProxies { return gce.gceTargetHttpsProxies } + +// TargetPools returns the interface for the ga TargetPools. func (gce *GCE) TargetPools() TargetPools { return gce.gceTargetPools } + +// UrlMaps returns the interface for the ga UrlMaps. func (gce *GCE) UrlMaps() UrlMaps { return gce.gceUrlMaps } + +// Zones returns the interface for the ga Zones. func (gce *GCE) Zones() Zones { return gce.gceZones } @@ -350,130 +413,162 @@ type MockGCE struct { MockZones *MockZones } +// Addresses returns the interface for the ga Addresses. func (mock *MockGCE) Addresses() Addresses { return mock.MockAddresses } +// AlphaAddresses returns the interface for the alpha Addresses. func (mock *MockGCE) AlphaAddresses() AlphaAddresses { return mock.MockAlphaAddresses } +// BetaAddresses returns the interface for the beta Addresses. func (mock *MockGCE) BetaAddresses() BetaAddresses { return mock.MockBetaAddresses } +// GlobalAddresses returns the interface for the ga GlobalAddresses. func (mock *MockGCE) GlobalAddresses() GlobalAddresses { return mock.MockGlobalAddresses } +// BackendServices returns the interface for the ga BackendServices. func (mock *MockGCE) BackendServices() BackendServices { return mock.MockBackendServices } +// AlphaBackendServices returns the interface for the alpha BackendServices. func (mock *MockGCE) AlphaBackendServices() AlphaBackendServices { return mock.MockAlphaBackendServices } +// AlphaRegionBackendServices returns the interface for the alpha RegionBackendServices. func (mock *MockGCE) AlphaRegionBackendServices() AlphaRegionBackendServices { return mock.MockAlphaRegionBackendServices } +// Disks returns the interface for the ga Disks. func (mock *MockGCE) Disks() Disks { return mock.MockDisks } +// AlphaDisks returns the interface for the alpha Disks. func (mock *MockGCE) AlphaDisks() AlphaDisks { return mock.MockAlphaDisks } +// AlphaRegionDisks returns the interface for the alpha RegionDisks. func (mock *MockGCE) AlphaRegionDisks() AlphaRegionDisks { return mock.MockAlphaRegionDisks } +// Firewalls returns the interface for the ga Firewalls. func (mock *MockGCE) Firewalls() Firewalls { return mock.MockFirewalls } +// ForwardingRules returns the interface for the ga ForwardingRules. func (mock *MockGCE) ForwardingRules() ForwardingRules { return mock.MockForwardingRules } +// AlphaForwardingRules returns the interface for the alpha ForwardingRules. func (mock *MockGCE) AlphaForwardingRules() AlphaForwardingRules { return mock.MockAlphaForwardingRules } +// GlobalForwardingRules returns the interface for the ga GlobalForwardingRules. func (mock *MockGCE) GlobalForwardingRules() GlobalForwardingRules { return mock.MockGlobalForwardingRules } +// HealthChecks returns the interface for the ga HealthChecks. func (mock *MockGCE) HealthChecks() HealthChecks { return mock.MockHealthChecks } +// AlphaHealthChecks returns the interface for the alpha HealthChecks. func (mock *MockGCE) AlphaHealthChecks() AlphaHealthChecks { return mock.MockAlphaHealthChecks } +// HttpHealthChecks returns the interface for the ga HttpHealthChecks. func (mock *MockGCE) HttpHealthChecks() HttpHealthChecks { return mock.MockHttpHealthChecks } +// HttpsHealthChecks returns the interface for the ga HttpsHealthChecks. func (mock *MockGCE) HttpsHealthChecks() HttpsHealthChecks { return mock.MockHttpsHealthChecks } +// InstanceGroups returns the interface for the ga InstanceGroups. func (mock *MockGCE) InstanceGroups() InstanceGroups { return mock.MockInstanceGroups } +// Instances returns the interface for the ga Instances. func (mock *MockGCE) Instances() Instances { return mock.MockInstances } +// BetaInstances returns the interface for the beta Instances. func (mock *MockGCE) BetaInstances() BetaInstances { return mock.MockBetaInstances } +// AlphaInstances returns the interface for the alpha Instances. func (mock *MockGCE) AlphaInstances() AlphaInstances { return mock.MockAlphaInstances } +// AlphaNetworkEndpointGroups returns the interface for the alpha NetworkEndpointGroups. func (mock *MockGCE) AlphaNetworkEndpointGroups() AlphaNetworkEndpointGroups { return mock.MockAlphaNetworkEndpointGroups } +// Projects returns the interface for the ga Projects. func (mock *MockGCE) Projects() Projects { return mock.MockProjects } +// Regions returns the interface for the ga Regions. func (mock *MockGCE) Regions() Regions { return mock.MockRegions } +// Routes returns the interface for the ga Routes. func (mock *MockGCE) Routes() Routes { return mock.MockRoutes } +// SslCertificates returns the interface for the ga SslCertificates. func (mock *MockGCE) SslCertificates() SslCertificates { return mock.MockSslCertificates } +// TargetHttpProxies returns the interface for the ga TargetHttpProxies. func (mock *MockGCE) TargetHttpProxies() TargetHttpProxies { return mock.MockTargetHttpProxies } +// TargetHttpsProxies returns the interface for the ga TargetHttpsProxies. func (mock *MockGCE) TargetHttpsProxies() TargetHttpsProxies { return mock.MockTargetHttpsProxies } +// TargetPools returns the interface for the ga TargetPools. func (mock *MockGCE) TargetPools() TargetPools { return mock.MockTargetPools } +// UrlMaps returns the interface for the ga UrlMaps. func (mock *MockGCE) UrlMaps() UrlMaps { return mock.MockUrlMaps } +// Zones returns the interface for the ga Zones. func (mock *MockGCE) Zones() Zones { return mock.MockZones } diff --git a/pkg/cloudprovider/providers/gce/cloud/gen/main.go b/pkg/cloudprovider/providers/gce/cloud/gen/main.go index f8dcd730b9f..7217d35c5d6 100644 --- a/pkg/cloudprovider/providers/gce/cloud/gen/main.go +++ b/pkg/cloudprovider/providers/gce/cloud/gen/main.go @@ -30,8 +30,8 @@ import ( "text/template" "time" - "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" "github.com/golang/glog" + "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" ) const ( @@ -167,6 +167,7 @@ type GCE struct { } {{range .All}} +// {{.WrapType}} returns the interface for the {{.Version}} {{.Service}}. func (gce *GCE) {{.WrapType}}() {{.WrapType}} { return gce.{{.Field}} } @@ -196,6 +197,7 @@ type MockGCE struct { {{- end}} } {{range .All}} +// {{.WrapType}} returns the interface for the {{.Version}} {{.Service}}. func (mock *MockGCE) {{.WrapType}}() {{.WrapType}} { return mock.{{.MockField}} } diff --git a/pkg/cloudprovider/providers/gce/cloud/meta/method.go b/pkg/cloudprovider/providers/gce/cloud/meta/method.go index 5adf065fae4..c3a33d801d3 100644 --- a/pkg/cloudprovider/providers/gce/cloud/meta/method.go +++ b/pkg/cloudprovider/providers/gce/cloud/meta/method.go @@ -91,7 +91,7 @@ func newMethod(s *ServiceInfo, m reflect.Method) *Method { return ret } -// Method is used to generate the calling code non-standard methods. +// Method is used to generate the calling code for non-standard methods. type Method struct { *ServiceInfo m reflect.Method @@ -135,6 +135,7 @@ func (mr *Method) args(skip int, nameArgs bool, prefix []string) []string { return append(prefix, a...) } +// init the method, preforming some rudimentary static checking. func (mr *Method) init() { fType := mr.m.Func.Type() if fType.NumIn() < mr.argsSkip() { @@ -189,10 +190,14 @@ func (mr *Method) init() { } } +// Name is the name of the method. func (mr *Method) Name() string { return mr.m.Name } +// CallArgs is a list of comma separated "argN" used for calling the method. +// For example, if the method has two additional arguments, this will return +// "arg0, arg1". func (mr *Method) CallArgs() string { var args []string for i := mr.argsSkip(); i < mr.m.Func.Type().NumIn(); i++ { @@ -204,10 +209,12 @@ func (mr *Method) CallArgs() string { return fmt.Sprintf(", %s", strings.Join(args, ", ")) } +// MockHookName is the name of the hook function in the mock. func (mr *Method) MockHookName() string { return mr.m.Name + "Hook" } +// MockHook is the definition of the hook function. func (mr *Method) MockHook() string { args := mr.args(mr.argsSkip(), false, []string{ fmt.Sprintf("*%s", mr.MockWrapType()), @@ -220,6 +227,7 @@ func (mr *Method) MockHook() string { return fmt.Sprintf("%v func(%v) (*%v.%v, error)", mr.MockHookName(), strings.Join(args, ", "), mr.Version(), mr.ReturnType) } +// FcnArgs is the function signature for the definition of the method. func (mr *Method) FcnArgs() string { args := mr.args(mr.argsSkip(), true, []string{ "ctx context.Context", @@ -232,6 +240,7 @@ func (mr *Method) FcnArgs() string { return fmt.Sprintf("%v(%v) (*%v.%v, error)", mr.m.Name, strings.Join(args, ", "), mr.Version(), mr.ReturnType) } +// InterfaceFunc is the function declaration of the method in the interface. func (mr *Method) InterfaceFunc() string { args := mr.args(mr.argsSkip(), false, []string{"context.Context", "meta.Key"}) if mr.ReturnType == "Operation" { diff --git a/pkg/cloudprovider/providers/gce/cloud/meta/service.go b/pkg/cloudprovider/providers/gce/cloud/meta/service.go index ffa3385075b..b2ba91c8ec5 100644 --- a/pkg/cloudprovider/providers/gce/cloud/meta/service.go +++ b/pkg/cloudprovider/providers/gce/cloud/meta/service.go @@ -220,6 +220,7 @@ type ServiceGroup struct { GA *ServiceInfo } +// Service returns any ServiceInfo object belonging to the ServiceGroup. func (sg *ServiceGroup) Service() string { switch { case sg.GA != nil: @@ -233,14 +234,17 @@ func (sg *ServiceGroup) Service() string { } } +// HasGA returns true if this object has a GA representation. func (sg *ServiceGroup) HasGA() bool { return sg.GA != nil } +// HasAlpha returns true if this object has a Alpha representation. func (sg *ServiceGroup) HasAlpha() bool { return sg.Alpha != nil } +// HasBeta returns true if this object has a Beta representation. func (sg *ServiceGroup) HasBeta() bool { return sg.Beta != nil } diff --git a/pkg/cloudprovider/providers/gce/cloud/project.go b/pkg/cloudprovider/providers/gce/cloud/project.go index 74299e4a23e..231e7cf916a 100644 --- a/pkg/cloudprovider/providers/gce/cloud/project.go +++ b/pkg/cloudprovider/providers/gce/cloud/project.go @@ -39,6 +39,7 @@ type SingleProjectRouter struct { ID string } +// ProjectID returns the project ID to be used for a call to the API. func (r *SingleProjectRouter) ProjectID(ctx context.Context, version meta.Version, service string) string { return r.ID } diff --git a/pkg/cloudprovider/providers/gce/cloud/ratelimit.go b/pkg/cloudprovider/providers/gce/cloud/ratelimit.go index 948f1d36d89..e38b8f7de3c 100644 --- a/pkg/cloudprovider/providers/gce/cloud/ratelimit.go +++ b/pkg/cloudprovider/providers/gce/cloud/ratelimit.go @@ -51,6 +51,7 @@ type RateLimiter interface { type NopRateLimiter struct { } +// Accept the operation to be rate limited. func (*NopRateLimiter) Accept(ctx context.Context, key *RateLimitKey) error { // Rate limit polling of the Operation status to avoid hammering GCE // for the status of an operation. From adaaed102835e02957d1f3c951ca654cea1a432d Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Fri, 5 Jan 2018 11:55:58 -0800 Subject: [PATCH 13/18] Ignore golint failures for bad compute API names --- hack/.golint_failures | 1 + 1 file changed, 1 insertion(+) diff --git a/hack/.golint_failures b/hack/.golint_failures index c7cd6939add..92f25955ec8 100644 --- a/hack/.golint_failures +++ b/hack/.golint_failures @@ -87,6 +87,7 @@ pkg/cloudprovider pkg/cloudprovider/providers/aws pkg/cloudprovider/providers/fake pkg/cloudprovider/providers/gce +pkg/cloudprovider/providers/gce/cloud pkg/cloudprovider/providers/openstack pkg/cloudprovider/providers/ovirt pkg/cloudprovider/providers/photon From c3e23b1b145455b521fb2d15c5ccf06aac520fb6 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Fri, 5 Jan 2018 13:36:21 -0800 Subject: [PATCH 14/18] Fix gofmt --- .../providers/gce/cloud/meta/meta.go | 72 +++++++++---------- .../providers/gce/cloud/utils_test.go | 4 +- 2 files changed, 38 insertions(+), 38 deletions(-) diff --git a/pkg/cloudprovider/providers/gce/cloud/meta/meta.go b/pkg/cloudprovider/providers/gce/cloud/meta/meta.go index 3f60c00f412..e1f36904d01 100644 --- a/pkg/cloudprovider/providers/gce/cloud/meta/meta.go +++ b/pkg/cloudprovider/providers/gce/cloud/meta/meta.go @@ -65,14 +65,14 @@ var AllVersions = []Version{ // 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", @@ -80,7 +80,7 @@ var AllServices = []*ServiceInfo{ keyType: Regional, serviceType: reflect.TypeOf(&alpha.AddressesService{}), }, - &ServiceInfo{ + { Object: "Address", Service: "Addresses", Resource: "addresses", @@ -88,14 +88,14 @@ var AllServices = []*ServiceInfo{ 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", @@ -106,16 +106,16 @@ var AllServices = []*ServiceInfo{ "Update", }, }, - &ServiceInfo{ + { Object: "BackendService", Service: "BackendServices", - Resource: "backendServices", + Resource: "backendServices", version: VersionAlpha, keyType: Global, serviceType: reflect.TypeOf(&alpha.BackendServicesService{}), additionalMethods: []string{"Update"}, }, - &ServiceInfo{ + { Object: "BackendService", Service: "RegionBackendServices", Resource: "backendServices", @@ -127,14 +127,14 @@ var AllServices = []*ServiceInfo{ "Update", }, }, - &ServiceInfo{ + { Object: "Disk", Service: "Disks", Resource: "disks", keyType: Zonal, serviceType: reflect.TypeOf(&ga.DisksService{}), }, - &ServiceInfo{ + { Object: "Disk", Service: "Disks", Resource: "disks", @@ -142,7 +142,7 @@ var AllServices = []*ServiceInfo{ keyType: Zonal, serviceType: reflect.TypeOf(&alpha.DisksService{}), }, - &ServiceInfo{ + { Object: "Disk", Service: "RegionDisks", Resource: "disks", @@ -150,7 +150,7 @@ var AllServices = []*ServiceInfo{ keyType: Regional, serviceType: reflect.TypeOf(&alpha.DisksService{}), }, - &ServiceInfo{ + { Object: "Firewall", Service: "Firewalls", Resource: "firewalls", @@ -160,14 +160,14 @@ var AllServices = []*ServiceInfo{ "Update", }, }, - &ServiceInfo{ + { Object: "ForwardingRule", Service: "ForwardingRules", Resource: "forwardingRules", keyType: Regional, serviceType: reflect.TypeOf(&ga.ForwardingRulesService{}), }, - &ServiceInfo{ + { Object: "ForwardingRule", Service: "ForwardingRules", Resource: "forwardingRules", @@ -175,7 +175,7 @@ var AllServices = []*ServiceInfo{ keyType: Regional, serviceType: reflect.TypeOf(&alpha.ForwardingRulesService{}), }, - &ServiceInfo{ + { Object: "ForwardingRule", Service: "GlobalForwardingRules", Resource: "forwardingRules", @@ -185,7 +185,7 @@ var AllServices = []*ServiceInfo{ "SetTarget", }, }, - &ServiceInfo{ + { Object: "HealthCheck", Service: "HealthChecks", Resource: "healthChecks", @@ -195,7 +195,7 @@ var AllServices = []*ServiceInfo{ "Update", }, }, - &ServiceInfo{ + { Object: "HealthCheck", Service: "HealthChecks", Resource: "healthChecks", @@ -206,7 +206,7 @@ var AllServices = []*ServiceInfo{ "Update", }, }, - &ServiceInfo{ + { Object: "HttpHealthCheck", Service: "HttpHealthChecks", Resource: "httpHealthChecks", @@ -216,7 +216,7 @@ var AllServices = []*ServiceInfo{ "Update", }, }, - &ServiceInfo{ + { Object: "HttpsHealthCheck", Service: "HttpsHealthChecks", Resource: "httpsHealthChecks", @@ -226,7 +226,7 @@ var AllServices = []*ServiceInfo{ "Update", }, }, - &ServiceInfo{ + { Object: "InstanceGroup", Service: "InstanceGroups", Resource: "instanceGroups", @@ -239,7 +239,7 @@ var AllServices = []*ServiceInfo{ "SetNamedPorts", }, }, - &ServiceInfo{ + { Object: "Instance", Service: "Instances", Resource: "instances", @@ -250,7 +250,7 @@ var AllServices = []*ServiceInfo{ "DetachDisk", }, }, - &ServiceInfo{ + { Object: "Instance", Service: "Instances", Resource: "instances", @@ -262,7 +262,7 @@ var AllServices = []*ServiceInfo{ "DetachDisk", }, }, - &ServiceInfo{ + { Object: "Instance", Service: "Instances", Resource: "instances", @@ -275,7 +275,7 @@ var AllServices = []*ServiceInfo{ "UpdateNetworkInterface", }, }, - &ServiceInfo{ + { Object: "NetworkEndpointGroup", Service: "NetworkEndpointGroups", Resource: "networkEndpointGroups", @@ -288,16 +288,16 @@ var AllServices = []*ServiceInfo{ }, options: AggregatedList, }, - &ServiceInfo{ - Object: "Project", - Service: "Projects", + { + Object: "Project", + Service: "Projects", Resource: "projects", - keyType: Global, + 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", @@ -305,21 +305,21 @@ var AllServices = []*ServiceInfo{ 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", @@ -329,7 +329,7 @@ var AllServices = []*ServiceInfo{ "SetUrlMap", }, }, - &ServiceInfo{ + { Object: "TargetHttpsProxy", Service: "TargetHttpsProxies", Resource: "targetHttpsProxies", @@ -340,7 +340,7 @@ var AllServices = []*ServiceInfo{ "SetUrlMap", }, }, - &ServiceInfo{ + { Object: "TargetPool", Service: "TargetPools", Resource: "targetPools", @@ -351,7 +351,7 @@ var AllServices = []*ServiceInfo{ "RemoveInstance", }, }, - &ServiceInfo{ + { Object: "UrlMap", Service: "UrlMaps", Resource: "urlMaps", @@ -361,7 +361,7 @@ var AllServices = []*ServiceInfo{ "Update", }, }, - &ServiceInfo{ + { Object: "Zone", Service: "Zones", Resource: "zones", diff --git a/pkg/cloudprovider/providers/gce/cloud/utils_test.go b/pkg/cloudprovider/providers/gce/cloud/utils_test.go index 823c8e73c88..562d0f35ba7 100644 --- a/pkg/cloudprovider/providers/gce/cloud/utils_test.go +++ b/pkg/cloudprovider/providers/gce/cloud/utils_test.go @@ -161,7 +161,7 @@ func TestCopyVisJSON(t *testing.T) { func TestSelfLink(t *testing.T) { t.Parallel() - for _, tc := range []struct{ + for _, tc := range []struct { ver meta.Version project string resource string @@ -189,7 +189,7 @@ func TestSelfLink(t *testing.T) { *meta.GlobalKey("key3"), "https://www.googleapis.com/compute/v1/projects/proj4/urlMaps/key3", }, - }{ + } { if link := SelfLink(tc.ver, tc.project, tc.resource, tc.key); link != tc.want { t.Errorf("SelfLink(%v, %q, %q, %v) = %v, want %q", tc.ver, tc.project, tc.resource, tc.key, link, tc.want) } From 5abf80718e3d5591204905c2b2b6d178f9b12104 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Tue, 9 Jan 2018 16:57:15 -0800 Subject: [PATCH 15/18] Remove glog dependency in the generator --- pkg/cloudprovider/providers/gce/cloud/gen/main.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/cloudprovider/providers/gce/cloud/gen/main.go b/pkg/cloudprovider/providers/gce/cloud/gen/main.go index 7217d35c5d6..ee48b374362 100644 --- a/pkg/cloudprovider/providers/gce/cloud/gen/main.go +++ b/pkg/cloudprovider/providers/gce/cloud/gen/main.go @@ -25,12 +25,12 @@ import ( "flag" "fmt" "io" + "log" "os" "os/exec" "text/template" "time" - "github.com/golang/glog" "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta" ) @@ -1131,7 +1131,7 @@ func main() { genUnitTestHeader(out) genUnitTestServices(out) default: - glog.Fatalf("Invalid -mode: %q", flags.mode) + log.Fatalf("Invalid -mode: %q", flags.mode) } if flags.gofmt { From e609cda0d2ee6e69ed31740349aaad85edf89ec9 Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Tue, 9 Jan 2018 17:07:10 -0800 Subject: [PATCH 16/18] hack/ scripts to keep the generated code in sync --- hack/update-cloudprovider-gce.sh | 36 +++++++++++++++++++++++ hack/verify-cloudprovider-gce.sh | 50 ++++++++++++++++++++++++++++++++ 2 files changed, 86 insertions(+) create mode 100755 hack/update-cloudprovider-gce.sh create mode 100755 hack/verify-cloudprovider-gce.sh diff --git a/hack/update-cloudprovider-gce.sh b/hack/update-cloudprovider-gce.sh new file mode 100755 index 00000000000..b7d606c95b4 --- /dev/null +++ b/hack/update-cloudprovider-gce.sh @@ -0,0 +1,36 @@ +#!/bin/bash +# 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. +set -o errexit +set -o nounset +set -o pipefail + +KUBE_ROOT=$(dirname "${BASH_SOURCE}")/.. +source "${KUBE_ROOT}/hack/lib/init.sh" +GENERATOR="${KUBE_ROOT}/pkg/cloudprovider/providers/gce/cloud/gen/main.go" + +GEN_GO="${KUBE_ROOT}/pkg/cloudprovider/providers/gce/cloud/gen.go" +GEN_TEST_GO="${KUBE_ROOT}/pkg/cloudprovider/providers/gce/cloud/gen_test.go" + +kube::golang::setup_env + +TMPFILE=$(mktemp verify-cloudprovider-gce-XXXX) +trap "{ rm -f ${TMPFILE}; }" EXIT + +go run "${GENERATOR}" > ${TMPFILE} +mv "${TMPFILE}" "${GEN_GO}" +go run "${GENERATOR}" -mode test > ${TMPFILE} +mv "${TMPFILE}" "${GEN_TEST_GO}" + +exit 0 diff --git a/hack/verify-cloudprovider-gce.sh b/hack/verify-cloudprovider-gce.sh new file mode 100755 index 00000000000..c7615d36592 --- /dev/null +++ b/hack/verify-cloudprovider-gce.sh @@ -0,0 +1,50 @@ +#!/bin/bash +#!/bin/bash + +# 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. + +set -o errexit +set -o nounset +set -o pipefail + +KUBE_ROOT=$(dirname "${BASH_SOURCE}")/.. +source "${KUBE_ROOT}/hack/lib/init.sh" +GENERATOR="${KUBE_ROOT}/pkg/cloudprovider/providers/gce/cloud/gen/main.go" + +GEN_GO="${KUBE_ROOT}/pkg/cloudprovider/providers/gce/cloud/gen.go" +GEN_TEST_GO="${KUBE_ROOT}/pkg/cloudprovider/providers/gce/cloud/gen_test.go" + +kube::golang::setup_env + +TMPFILE=$(mktemp verify-cloudprovider-gce-XXXX) +trap "{ rm -f ${TMPFILE}; }" EXIT + +go run "${GENERATOR}" > ${TMPFILE} +if ! diff "${TMPFILE}" "${GEN_GO}"; then + echo "Generated file ${GEN_GO} needs to be updated (run hack/update-cloudprovider-gce.sh)" + echo + diff -u "${TMPFILE}" "${GEN_GO}" || true + exit 1 +fi + +go run "${GENERATOR}" -mode test > ${TMPFILE} +if ! diff "${TMPFILE}" "${GEN_TEST_GO}"; then + echo "Generated file ${GEN_TEST_GO} needs to be updated (run hack/update-cloudprovider-gce.sh)" + echo + diff -u "${TMPFILE}" "${GEN_TEST_GO}" || true + exit 1 +fi + +exit 0 From 8cdfe362671dc6a7b93f8bfec0e813ee66f0604b Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Tue, 9 Jan 2018 17:07:22 -0800 Subject: [PATCH 17/18] Update generated code to stable order --- .../providers/gce/cloud/gen/main.go | 10 +- .../providers/gce/cloud/gen_test.go | 1928 ++++++++--------- 2 files changed, 973 insertions(+), 965 deletions(-) diff --git a/pkg/cloudprovider/providers/gce/cloud/gen/main.go b/pkg/cloudprovider/providers/gce/cloud/gen/main.go index ee48b374362..ba0dd9cc2f0 100644 --- a/pkg/cloudprovider/providers/gce/cloud/gen/main.go +++ b/pkg/cloudprovider/providers/gce/cloud/gen/main.go @@ -28,6 +28,7 @@ import ( "log" "os" "os/exec" + "sort" "text/template" "time" @@ -1110,7 +1111,14 @@ func Test{{.Service}}Group(t *testing.T) { } ` tmpl := template.Must(template.New("unittest").Parse(text)) - for _, s := range meta.AllServicesByGroup { + // Sort keys so the output will be stable. + var keys []string + for k, _ := range meta.AllServicesByGroup { + keys = append(keys, k) + } + sort.Strings(keys) + for _, k := range keys { + s := meta.AllServicesByGroup[k] if err := tmpl.Execute(wr, s); err != nil { panic(err) } diff --git a/pkg/cloudprovider/providers/gce/cloud/gen_test.go b/pkg/cloudprovider/providers/gce/cloud/gen_test.go index cbe5d9938d3..ee7cb103753 100644 --- a/pkg/cloudprovider/providers/gce/cloud/gen_test.go +++ b/pkg/cloudprovider/providers/gce/cloud/gen_test.go @@ -34,6 +34,238 @@ import ( const location = "location" +func TestAddressesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + keyBeta := meta.RegionalKey("key-beta", "location") + key = keyBeta + keyGA := meta.RegionalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaAddresses().Get(ctx, *key); err == nil { + t.Errorf("AlphaAddresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BetaAddresses().Get(ctx, *key); err == nil { + t.Errorf("BetaAddresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.Addresses().Get(ctx, *key); err == nil { + t.Errorf("Addresses().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Address{} + if err := mock.AlphaAddresses().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &beta.Address{} + if err := mock.BetaAddresses().Insert(ctx, *keyBeta, obj); err != nil { + t.Errorf("BetaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.Address{} + if err := mock.Addresses().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Addresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaAddresses().Get(ctx, *key); err != nil { + t.Errorf("AlphaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BetaAddresses().Get(ctx, *key); err != nil { + t.Errorf("BetaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.Addresses().Get(ctx, *key); err != nil { + t.Errorf("Addresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaAddresses.Objects[*keyAlpha] = mock.MockAlphaAddresses.Obj(&alpha.Address{Name: keyAlpha.Name}) + mock.MockBetaAddresses.Objects[*keyBeta] = mock.MockBetaAddresses.Obj(&beta.Address{Name: keyBeta.Name}) + mock.MockAddresses.Objects[*keyGA] = mock.MockAddresses.Obj(&ga.Address{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-beta": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaAddresses().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BetaAddresses().List(ctx, location, filter.None) + if err != nil { + t.Errorf("BetaAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.Addresses().List(ctx, location, filter.None) + if err != nil { + t.Errorf("Addresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err != nil { + t.Errorf("BetaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.Addresses().Delete(ctx, *keyGA); err != nil { + t.Errorf("Addresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err == nil { + t.Errorf("BetaAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.Addresses().Delete(ctx, *keyGA); err == nil { + t.Errorf("Addresses().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestBackendServicesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.GlobalKey("key-alpha") + key = keyAlpha + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaBackendServices().Get(ctx, *key); err == nil { + t.Errorf("AlphaBackendServices().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BackendServices().Get(ctx, *key); err == nil { + t.Errorf("BackendServices().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.BackendService{} + if err := mock.AlphaBackendServices().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.BackendService{} + if err := mock.BackendServices().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("BackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaBackendServices().Get(ctx, *key); err != nil { + t.Errorf("AlphaBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BackendServices().Get(ctx, *key); err != nil { + t.Errorf("BackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaBackendServices.Objects[*keyAlpha] = mock.MockAlphaBackendServices.Obj(&alpha.BackendService{Name: keyAlpha.Name}) + mock.MockBackendServices.Objects[*keyGA] = mock.MockBackendServices.Obj(&ga.BackendService{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaBackendServices().List(ctx, filter.None) + if err != nil { + t.Errorf("AlphaBackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaBackendServices().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BackendServices().List(ctx, filter.None) + if err != nil { + t.Errorf("BackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaBackendServices().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaBackendServices().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaBackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.BackendServices().Delete(ctx, *keyGA); err != nil { + t.Errorf("BackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaBackendServices().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaBackendServices().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.BackendServices().Delete(ctx, *keyGA); err == nil { + t.Errorf("BackendServices().Delete(%v, %v) = nil; want error", ctx, key) + } +} + func TestDisksGroup(t *testing.T) { t.Parallel() @@ -194,749 +426,6 @@ func TestFirewallsGroup(t *testing.T) { } } -func TestInstancesGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyAlpha := meta.ZonalKey("key-alpha", "location") - key = keyAlpha - keyBeta := meta.ZonalKey("key-beta", "location") - key = keyBeta - keyGA := meta.ZonalKey("key-ga", "location") - key = keyGA - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.AlphaInstances().Get(ctx, *key); err == nil { - t.Errorf("AlphaInstances().Get(%v, %v) = _, nil; want error", ctx, key) - } - if _, err := mock.BetaInstances().Get(ctx, *key); err == nil { - t.Errorf("BetaInstances().Get(%v, %v) = _, nil; want error", ctx, key) - } - if _, err := mock.Instances().Get(ctx, *key); err == nil { - t.Errorf("Instances().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &alpha.Instance{} - if err := mock.AlphaInstances().Insert(ctx, *keyAlpha, obj); err != nil { - t.Errorf("AlphaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - { - obj := &beta.Instance{} - if err := mock.BetaInstances().Insert(ctx, *keyBeta, obj); err != nil { - t.Errorf("BetaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - { - obj := &ga.Instance{} - if err := mock.Instances().Insert(ctx, *keyGA, obj); err != nil { - t.Errorf("Instances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.AlphaInstances().Get(ctx, *key); err != nil { - t.Errorf("AlphaInstances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - if obj, err := mock.BetaInstances().Get(ctx, *key); err != nil { - t.Errorf("BetaInstances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - if obj, err := mock.Instances().Get(ctx, *key); err != nil { - t.Errorf("Instances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockAlphaInstances.Objects[*keyAlpha] = mock.MockAlphaInstances.Obj(&alpha.Instance{Name: keyAlpha.Name}) - mock.MockBetaInstances.Objects[*keyBeta] = mock.MockBetaInstances.Obj(&beta.Instance{Name: keyBeta.Name}) - mock.MockInstances.Objects[*keyGA] = mock.MockInstances.Obj(&ga.Instance{Name: keyGA.Name}) - want := map[string]bool{ - "key-alpha": true, - "key-beta": true, - "key-ga": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.AlphaInstances().List(ctx, location, filter.None) - if err != nil { - t.Errorf("AlphaInstances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) - } - } - } - { - objs, err := mock.BetaInstances().List(ctx, location, filter.None) - if err != nil { - t.Errorf("BetaInstances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) - } - } - } - { - objs, err := mock.Instances().List(ctx, location, filter.None) - if err != nil { - t.Errorf("Instances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.AlphaInstances().Delete(ctx, *keyAlpha); err != nil { - t.Errorf("AlphaInstances().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - if err := mock.BetaInstances().Delete(ctx, *keyBeta); err != nil { - t.Errorf("BetaInstances().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - if err := mock.Instances().Delete(ctx, *keyGA); err != nil { - t.Errorf("Instances().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.AlphaInstances().Delete(ctx, *keyAlpha); err == nil { - t.Errorf("AlphaInstances().Delete(%v, %v) = nil; want error", ctx, key) - } - if err := mock.BetaInstances().Delete(ctx, *keyBeta); err == nil { - t.Errorf("BetaInstances().Delete(%v, %v) = nil; want error", ctx, key) - } - if err := mock.Instances().Delete(ctx, *keyGA); err == nil { - t.Errorf("Instances().Delete(%v, %v) = nil; want error", ctx, key) - } -} - -func TestProjectsGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyGA := meta.GlobalKey("key-ga") - key = keyGA - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - - // Insert. - - // Get across versions. - - // List. - mock.MockProjects.Objects[*keyGA] = mock.MockProjects.Obj(&ga.Project{Name: keyGA.Name}) - want := map[string]bool{ - "key-ga": true, - } - _ = want // ignore unused variables. - - // Delete across versions. - - // Delete not found. -} - -func TestRoutesGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyGA := meta.GlobalKey("key-ga") - key = keyGA - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.Routes().Get(ctx, *key); err == nil { - t.Errorf("Routes().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &ga.Route{} - if err := mock.Routes().Insert(ctx, *keyGA, obj); err != nil { - t.Errorf("Routes().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.Routes().Get(ctx, *key); err != nil { - t.Errorf("Routes().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockRoutes.Objects[*keyGA] = mock.MockRoutes.Obj(&ga.Route{Name: keyGA.Name}) - want := map[string]bool{ - "key-ga": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.Routes().List(ctx, filter.None) - if err != nil { - t.Errorf("Routes().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaRoutes().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.Routes().Delete(ctx, *keyGA); err != nil { - t.Errorf("Routes().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.Routes().Delete(ctx, *keyGA); err == nil { - t.Errorf("Routes().Delete(%v, %v) = nil; want error", ctx, key) - } -} - -func TestTargetPoolsGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyGA := meta.RegionalKey("key-ga", "location") - key = keyGA - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.TargetPools().Get(ctx, *key); err == nil { - t.Errorf("TargetPools().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &ga.TargetPool{} - if err := mock.TargetPools().Insert(ctx, *keyGA, obj); err != nil { - t.Errorf("TargetPools().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.TargetPools().Get(ctx, *key); err != nil { - t.Errorf("TargetPools().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockTargetPools.Objects[*keyGA] = mock.MockTargetPools.Obj(&ga.TargetPool{Name: keyGA.Name}) - want := map[string]bool{ - "key-ga": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.TargetPools().List(ctx, location, filter.None) - if err != nil { - t.Errorf("TargetPools().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaTargetPools().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.TargetPools().Delete(ctx, *keyGA); err != nil { - t.Errorf("TargetPools().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.TargetPools().Delete(ctx, *keyGA); err == nil { - t.Errorf("TargetPools().Delete(%v, %v) = nil; want error", ctx, key) - } -} - -func TestGlobalForwardingRulesGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyGA := meta.GlobalKey("key-ga") - key = keyGA - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.GlobalForwardingRules().Get(ctx, *key); err == nil { - t.Errorf("GlobalForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &ga.ForwardingRule{} - if err := mock.GlobalForwardingRules().Insert(ctx, *keyGA, obj); err != nil { - t.Errorf("GlobalForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.GlobalForwardingRules().Get(ctx, *key); err != nil { - t.Errorf("GlobalForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockGlobalForwardingRules.Objects[*keyGA] = mock.MockGlobalForwardingRules.Obj(&ga.ForwardingRule{Name: keyGA.Name}) - want := map[string]bool{ - "key-ga": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.GlobalForwardingRules().List(ctx, filter.None) - if err != nil { - t.Errorf("GlobalForwardingRules().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaGlobalForwardingRules().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.GlobalForwardingRules().Delete(ctx, *keyGA); err != nil { - t.Errorf("GlobalForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.GlobalForwardingRules().Delete(ctx, *keyGA); err == nil { - t.Errorf("GlobalForwardingRules().Delete(%v, %v) = nil; want error", ctx, key) - } -} - -func TestNetworkEndpointGroupsGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyAlpha := meta.ZonalKey("key-alpha", "location") - key = keyAlpha - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.AlphaNetworkEndpointGroups().Get(ctx, *key); err == nil { - t.Errorf("AlphaNetworkEndpointGroups().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &alpha.NetworkEndpointGroup{} - if err := mock.AlphaNetworkEndpointGroups().Insert(ctx, *keyAlpha, obj); err != nil { - t.Errorf("AlphaNetworkEndpointGroups().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.AlphaNetworkEndpointGroups().Get(ctx, *key); err != nil { - t.Errorf("AlphaNetworkEndpointGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockAlphaNetworkEndpointGroups.Objects[*keyAlpha] = mock.MockAlphaNetworkEndpointGroups.Obj(&alpha.NetworkEndpointGroup{Name: keyAlpha.Name}) - want := map[string]bool{ - "key-alpha": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.AlphaNetworkEndpointGroups().List(ctx, location, filter.None) - if err != nil { - t.Errorf("AlphaNetworkEndpointGroups().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaNetworkEndpointGroups().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, *keyAlpha); err != nil { - t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, *keyAlpha); err == nil { - t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = nil; want error", ctx, key) - } -} - -func TestTargetHttpProxiesGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyGA := meta.GlobalKey("key-ga") - key = keyGA - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.TargetHttpProxies().Get(ctx, *key); err == nil { - t.Errorf("TargetHttpProxies().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &ga.TargetHttpProxy{} - if err := mock.TargetHttpProxies().Insert(ctx, *keyGA, obj); err != nil { - t.Errorf("TargetHttpProxies().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.TargetHttpProxies().Get(ctx, *key); err != nil { - t.Errorf("TargetHttpProxies().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockTargetHttpProxies.Objects[*keyGA] = mock.MockTargetHttpProxies.Obj(&ga.TargetHttpProxy{Name: keyGA.Name}) - want := map[string]bool{ - "key-ga": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.TargetHttpProxies().List(ctx, filter.None) - if err != nil { - t.Errorf("TargetHttpProxies().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaTargetHttpProxies().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.TargetHttpProxies().Delete(ctx, *keyGA); err != nil { - t.Errorf("TargetHttpProxies().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.TargetHttpProxies().Delete(ctx, *keyGA); err == nil { - t.Errorf("TargetHttpProxies().Delete(%v, %v) = nil; want error", ctx, key) - } -} - -func TestUrlMapsGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyGA := meta.GlobalKey("key-ga") - key = keyGA - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.UrlMaps().Get(ctx, *key); err == nil { - t.Errorf("UrlMaps().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &ga.UrlMap{} - if err := mock.UrlMaps().Insert(ctx, *keyGA, obj); err != nil { - t.Errorf("UrlMaps().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.UrlMaps().Get(ctx, *key); err != nil { - t.Errorf("UrlMaps().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockUrlMaps.Objects[*keyGA] = mock.MockUrlMaps.Obj(&ga.UrlMap{Name: keyGA.Name}) - want := map[string]bool{ - "key-ga": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.UrlMaps().List(ctx, filter.None) - if err != nil { - t.Errorf("UrlMaps().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaUrlMaps().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.UrlMaps().Delete(ctx, *keyGA); err != nil { - t.Errorf("UrlMaps().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.UrlMaps().Delete(ctx, *keyGA); err == nil { - t.Errorf("UrlMaps().Delete(%v, %v) = nil; want error", ctx, key) - } -} - -func TestZonesGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyGA := meta.GlobalKey("key-ga") - key = keyGA - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.Zones().Get(ctx, *key); err == nil { - t.Errorf("Zones().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - - // Get across versions. - - // List. - mock.MockZones.Objects[*keyGA] = mock.MockZones.Obj(&ga.Zone{Name: keyGA.Name}) - want := map[string]bool{ - "key-ga": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.Zones().List(ctx, filter.None) - if err != nil { - t.Errorf("Zones().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaZones().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - - // Delete not found. -} - -func TestGlobalAddressesGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyGA := meta.GlobalKey("key-ga") - key = keyGA - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.GlobalAddresses().Get(ctx, *key); err == nil { - t.Errorf("GlobalAddresses().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &ga.Address{} - if err := mock.GlobalAddresses().Insert(ctx, *keyGA, obj); err != nil { - t.Errorf("GlobalAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.GlobalAddresses().Get(ctx, *key); err != nil { - t.Errorf("GlobalAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockGlobalAddresses.Objects[*keyGA] = mock.MockGlobalAddresses.Obj(&ga.Address{Name: keyGA.Name}) - want := map[string]bool{ - "key-ga": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.GlobalAddresses().List(ctx, filter.None) - if err != nil { - t.Errorf("GlobalAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaGlobalAddresses().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.GlobalAddresses().Delete(ctx, *keyGA); err != nil { - t.Errorf("GlobalAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.GlobalAddresses().Delete(ctx, *keyGA); err == nil { - t.Errorf("GlobalAddresses().Delete(%v, %v) = nil; want error", ctx, key) - } -} - -func TestBackendServicesGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyAlpha := meta.GlobalKey("key-alpha") - key = keyAlpha - keyGA := meta.GlobalKey("key-ga") - key = keyGA - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.AlphaBackendServices().Get(ctx, *key); err == nil { - t.Errorf("AlphaBackendServices().Get(%v, %v) = _, nil; want error", ctx, key) - } - if _, err := mock.BackendServices().Get(ctx, *key); err == nil { - t.Errorf("BackendServices().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &alpha.BackendService{} - if err := mock.AlphaBackendServices().Insert(ctx, *keyAlpha, obj); err != nil { - t.Errorf("AlphaBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - { - obj := &ga.BackendService{} - if err := mock.BackendServices().Insert(ctx, *keyGA, obj); err != nil { - t.Errorf("BackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.AlphaBackendServices().Get(ctx, *key); err != nil { - t.Errorf("AlphaBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - if obj, err := mock.BackendServices().Get(ctx, *key); err != nil { - t.Errorf("BackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockAlphaBackendServices.Objects[*keyAlpha] = mock.MockAlphaBackendServices.Obj(&alpha.BackendService{Name: keyAlpha.Name}) - mock.MockBackendServices.Objects[*keyGA] = mock.MockBackendServices.Obj(&ga.BackendService{Name: keyGA.Name}) - want := map[string]bool{ - "key-alpha": true, - "key-ga": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.AlphaBackendServices().List(ctx, filter.None) - if err != nil { - t.Errorf("AlphaBackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaBackendServices().List(); got %+v, want %+v", got, want) - } - } - } - { - objs, err := mock.BackendServices().List(ctx, filter.None) - if err != nil { - t.Errorf("BackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaBackendServices().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.AlphaBackendServices().Delete(ctx, *keyAlpha); err != nil { - t.Errorf("AlphaBackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - if err := mock.BackendServices().Delete(ctx, *keyGA); err != nil { - t.Errorf("BackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.AlphaBackendServices().Delete(ctx, *keyAlpha); err == nil { - t.Errorf("AlphaBackendServices().Delete(%v, %v) = nil; want error", ctx, key) - } - if err := mock.BackendServices().Delete(ctx, *keyGA); err == nil { - t.Errorf("BackendServices().Delete(%v, %v) = nil; want error", ctx, key) - } -} - func TestForwardingRulesGroup(t *testing.T) { t.Parallel() @@ -1035,7 +524,7 @@ func TestForwardingRulesGroup(t *testing.T) { } } -func TestRegionsGroup(t *testing.T) { +func TestGlobalAddressesGroup(t *testing.T) { t.Parallel() ctx := context.Background() @@ -1048,295 +537,114 @@ func TestRegionsGroup(t *testing.T) { _, _, _ = ctx, mock, key // Get not found. - if _, err := mock.Regions().Get(ctx, *key); err == nil { - t.Errorf("Regions().Get(%v, %v) = _, nil; want error", ctx, key) + if _, err := mock.GlobalAddresses().Get(ctx, *key); err == nil { + t.Errorf("GlobalAddresses().Get(%v, %v) = _, nil; want error", ctx, key) } // Insert. + { + obj := &ga.Address{} + if err := mock.GlobalAddresses().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("GlobalAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } // Get across versions. + if obj, err := mock.GlobalAddresses().Get(ctx, *key); err != nil { + t.Errorf("GlobalAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } // List. - mock.MockRegions.Objects[*keyGA] = mock.MockRegions.Obj(&ga.Region{Name: keyGA.Name}) + mock.MockGlobalAddresses.Objects[*keyGA] = mock.MockGlobalAddresses.Obj(&ga.Address{Name: keyGA.Name}) want := map[string]bool{ "key-ga": true, } _ = want // ignore unused variables. { - objs, err := mock.Regions().List(ctx, filter.None) + objs, err := mock.GlobalAddresses().List(ctx, filter.None) if err != nil { - t.Errorf("Regions().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + t.Errorf("GlobalAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) } else { got := map[string]bool{} for _, obj := range objs { got[obj.Name] = true } if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaRegions().List(); got %+v, want %+v", got, want) + t.Errorf("AlphaGlobalAddresses().List(); got %+v, want %+v", got, want) } } } // Delete across versions. + if err := mock.GlobalAddresses().Delete(ctx, *keyGA); err != nil { + t.Errorf("GlobalAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + } // Delete not found. + if err := mock.GlobalAddresses().Delete(ctx, *keyGA); err == nil { + t.Errorf("GlobalAddresses().Delete(%v, %v) = nil; want error", ctx, key) + } } -func TestAddressesGroup(t *testing.T) { +func TestGlobalForwardingRulesGroup(t *testing.T) { t.Parallel() ctx := context.Background() mock := NewMockGCE() var key *meta.Key - keyAlpha := meta.RegionalKey("key-alpha", "location") - key = keyAlpha - keyBeta := meta.RegionalKey("key-beta", "location") - key = keyBeta - keyGA := meta.RegionalKey("key-ga", "location") + keyGA := meta.GlobalKey("key-ga") key = keyGA // Ignore unused variables. _, _, _ = ctx, mock, key // Get not found. - if _, err := mock.AlphaAddresses().Get(ctx, *key); err == nil { - t.Errorf("AlphaAddresses().Get(%v, %v) = _, nil; want error", ctx, key) - } - if _, err := mock.BetaAddresses().Get(ctx, *key); err == nil { - t.Errorf("BetaAddresses().Get(%v, %v) = _, nil; want error", ctx, key) - } - if _, err := mock.Addresses().Get(ctx, *key); err == nil { - t.Errorf("Addresses().Get(%v, %v) = _, nil; want error", ctx, key) + if _, err := mock.GlobalForwardingRules().Get(ctx, *key); err == nil { + t.Errorf("GlobalForwardingRules().Get(%v, %v) = _, nil; want error", ctx, key) } // Insert. { - obj := &alpha.Address{} - if err := mock.AlphaAddresses().Insert(ctx, *keyAlpha, obj); err != nil { - t.Errorf("AlphaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - { - obj := &beta.Address{} - if err := mock.BetaAddresses().Insert(ctx, *keyBeta, obj); err != nil { - t.Errorf("BetaAddresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - { - obj := &ga.Address{} - if err := mock.Addresses().Insert(ctx, *keyGA, obj); err != nil { - t.Errorf("Addresses().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + obj := &ga.ForwardingRule{} + if err := mock.GlobalForwardingRules().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("GlobalForwardingRules().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) } } // Get across versions. - if obj, err := mock.AlphaAddresses().Get(ctx, *key); err != nil { - t.Errorf("AlphaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - if obj, err := mock.BetaAddresses().Get(ctx, *key); err != nil { - t.Errorf("BetaAddresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - if obj, err := mock.Addresses().Get(ctx, *key); err != nil { - t.Errorf("Addresses().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + if obj, err := mock.GlobalForwardingRules().Get(ctx, *key); err != nil { + t.Errorf("GlobalForwardingRules().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) } // List. - mock.MockAlphaAddresses.Objects[*keyAlpha] = mock.MockAlphaAddresses.Obj(&alpha.Address{Name: keyAlpha.Name}) - mock.MockBetaAddresses.Objects[*keyBeta] = mock.MockBetaAddresses.Obj(&beta.Address{Name: keyBeta.Name}) - mock.MockAddresses.Objects[*keyGA] = mock.MockAddresses.Obj(&ga.Address{Name: keyGA.Name}) + mock.MockGlobalForwardingRules.Objects[*keyGA] = mock.MockGlobalForwardingRules.Obj(&ga.ForwardingRule{Name: keyGA.Name}) want := map[string]bool{ - "key-alpha": true, - "key-beta": true, - "key-ga": true, + "key-ga": true, } _ = want // ignore unused variables. { - objs, err := mock.AlphaAddresses().List(ctx, location, filter.None) + objs, err := mock.GlobalForwardingRules().List(ctx, filter.None) if err != nil { - t.Errorf("AlphaAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + t.Errorf("GlobalForwardingRules().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) } else { got := map[string]bool{} for _, obj := range objs { got[obj.Name] = true } if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) - } - } - } - { - objs, err := mock.BetaAddresses().List(ctx, location, filter.None) - if err != nil { - t.Errorf("BetaAddresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) - } - } - } - { - objs, err := mock.Addresses().List(ctx, location, filter.None) - if err != nil { - t.Errorf("Addresses().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaAddresses().List(); got %+v, want %+v", got, want) + t.Errorf("AlphaGlobalForwardingRules().List(); got %+v, want %+v", got, want) } } } // Delete across versions. - if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err != nil { - t.Errorf("AlphaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err != nil { - t.Errorf("BetaAddresses().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - if err := mock.Addresses().Delete(ctx, *keyGA); err != nil { - t.Errorf("Addresses().Delete(%v, %v) = %v; want nil", ctx, key, err) + if err := mock.GlobalForwardingRules().Delete(ctx, *keyGA); err != nil { + t.Errorf("GlobalForwardingRules().Delete(%v, %v) = %v; want nil", ctx, key, err) } // Delete not found. - if err := mock.AlphaAddresses().Delete(ctx, *keyAlpha); err == nil { - t.Errorf("AlphaAddresses().Delete(%v, %v) = nil; want error", ctx, key) - } - if err := mock.BetaAddresses().Delete(ctx, *keyBeta); err == nil { - t.Errorf("BetaAddresses().Delete(%v, %v) = nil; want error", ctx, key) - } - if err := mock.Addresses().Delete(ctx, *keyGA); err == nil { - t.Errorf("Addresses().Delete(%v, %v) = nil; want error", ctx, key) - } -} - -func TestRegionBackendServicesGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyAlpha := meta.RegionalKey("key-alpha", "location") - key = keyAlpha - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.AlphaRegionBackendServices().Get(ctx, *key); err == nil { - t.Errorf("AlphaRegionBackendServices().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &alpha.BackendService{} - if err := mock.AlphaRegionBackendServices().Insert(ctx, *keyAlpha, obj); err != nil { - t.Errorf("AlphaRegionBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.AlphaRegionBackendServices().Get(ctx, *key); err != nil { - t.Errorf("AlphaRegionBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockAlphaRegionBackendServices.Objects[*keyAlpha] = mock.MockAlphaRegionBackendServices.Obj(&alpha.BackendService{Name: keyAlpha.Name}) - want := map[string]bool{ - "key-alpha": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.AlphaRegionBackendServices().List(ctx, location, filter.None) - if err != nil { - t.Errorf("AlphaRegionBackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaRegionBackendServices().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.AlphaRegionBackendServices().Delete(ctx, *keyAlpha); err != nil { - t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.AlphaRegionBackendServices().Delete(ctx, *keyAlpha); err == nil { - t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = nil; want error", ctx, key) - } -} - -func TestRegionDisksGroup(t *testing.T) { - t.Parallel() - - ctx := context.Background() - mock := NewMockGCE() - - var key *meta.Key - keyAlpha := meta.RegionalKey("key-alpha", "location") - key = keyAlpha - // Ignore unused variables. - _, _, _ = ctx, mock, key - - // Get not found. - if _, err := mock.AlphaRegionDisks().Get(ctx, *key); err == nil { - t.Errorf("AlphaRegionDisks().Get(%v, %v) = _, nil; want error", ctx, key) - } - - // Insert. - { - obj := &alpha.Disk{} - if err := mock.AlphaRegionDisks().Insert(ctx, *keyAlpha, obj); err != nil { - t.Errorf("AlphaRegionDisks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) - } - } - - // Get across versions. - if obj, err := mock.AlphaRegionDisks().Get(ctx, *key); err != nil { - t.Errorf("AlphaRegionDisks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) - } - - // List. - mock.MockAlphaRegionDisks.Objects[*keyAlpha] = mock.MockAlphaRegionDisks.Obj(&alpha.Disk{Name: keyAlpha.Name}) - want := map[string]bool{ - "key-alpha": true, - } - _ = want // ignore unused variables. - { - objs, err := mock.AlphaRegionDisks().List(ctx, location, filter.None) - if err != nil { - t.Errorf("AlphaRegionDisks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) - } else { - got := map[string]bool{} - for _, obj := range objs { - got[obj.Name] = true - } - if !reflect.DeepEqual(got, want) { - t.Errorf("AlphaRegionDisks().List(); got %+v, want %+v", got, want) - } - } - } - - // Delete across versions. - if err := mock.AlphaRegionDisks().Delete(ctx, *keyAlpha); err != nil { - t.Errorf("AlphaRegionDisks().Delete(%v, %v) = %v; want nil", ctx, key, err) - } - - // Delete not found. - if err := mock.AlphaRegionDisks().Delete(ctx, *keyAlpha); err == nil { - t.Errorf("AlphaRegionDisks().Delete(%v, %v) = nil; want error", ctx, key) + if err := mock.GlobalForwardingRules().Delete(ctx, *keyGA); err == nil { + t.Errorf("GlobalForwardingRules().Delete(%v, %v) = nil; want error", ctx, key) } } @@ -1624,6 +932,465 @@ func TestInstanceGroupsGroup(t *testing.T) { } } +func TestInstancesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.ZonalKey("key-alpha", "location") + key = keyAlpha + keyBeta := meta.ZonalKey("key-beta", "location") + key = keyBeta + keyGA := meta.ZonalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaInstances().Get(ctx, *key); err == nil { + t.Errorf("AlphaInstances().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.BetaInstances().Get(ctx, *key); err == nil { + t.Errorf("BetaInstances().Get(%v, %v) = _, nil; want error", ctx, key) + } + if _, err := mock.Instances().Get(ctx, *key); err == nil { + t.Errorf("Instances().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Instance{} + if err := mock.AlphaInstances().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &beta.Instance{} + if err := mock.BetaInstances().Insert(ctx, *keyBeta, obj); err != nil { + t.Errorf("BetaInstances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + { + obj := &ga.Instance{} + if err := mock.Instances().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Instances().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaInstances().Get(ctx, *key); err != nil { + t.Errorf("AlphaInstances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.BetaInstances().Get(ctx, *key); err != nil { + t.Errorf("BetaInstances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + if obj, err := mock.Instances().Get(ctx, *key); err != nil { + t.Errorf("Instances().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaInstances.Objects[*keyAlpha] = mock.MockAlphaInstances.Obj(&alpha.Instance{Name: keyAlpha.Name}) + mock.MockBetaInstances.Objects[*keyBeta] = mock.MockBetaInstances.Obj(&beta.Instance{Name: keyBeta.Name}) + mock.MockInstances.Objects[*keyGA] = mock.MockInstances.Obj(&ga.Instance{Name: keyGA.Name}) + want := map[string]bool{ + "key-alpha": true, + "key-beta": true, + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaInstances().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaInstances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.BetaInstances().List(ctx, location, filter.None) + if err != nil { + t.Errorf("BetaInstances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) + } + } + } + { + objs, err := mock.Instances().List(ctx, location, filter.None) + if err != nil { + t.Errorf("Instances().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaInstances().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaInstances().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaInstances().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.BetaInstances().Delete(ctx, *keyBeta); err != nil { + t.Errorf("BetaInstances().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + if err := mock.Instances().Delete(ctx, *keyGA); err != nil { + t.Errorf("Instances().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaInstances().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaInstances().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.BetaInstances().Delete(ctx, *keyBeta); err == nil { + t.Errorf("BetaInstances().Delete(%v, %v) = nil; want error", ctx, key) + } + if err := mock.Instances().Delete(ctx, *keyGA); err == nil { + t.Errorf("Instances().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestNetworkEndpointGroupsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.ZonalKey("key-alpha", "location") + key = keyAlpha + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaNetworkEndpointGroups().Get(ctx, *key); err == nil { + t.Errorf("AlphaNetworkEndpointGroups().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.NetworkEndpointGroup{} + if err := mock.AlphaNetworkEndpointGroups().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaNetworkEndpointGroups().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaNetworkEndpointGroups().Get(ctx, *key); err != nil { + t.Errorf("AlphaNetworkEndpointGroups().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaNetworkEndpointGroups.Objects[*keyAlpha] = mock.MockAlphaNetworkEndpointGroups.Obj(&alpha.NetworkEndpointGroup{Name: keyAlpha.Name}) + want := map[string]bool{ + "key-alpha": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaNetworkEndpointGroups().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaNetworkEndpointGroups().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaNetworkEndpointGroups().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaNetworkEndpointGroups().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaNetworkEndpointGroups().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestProjectsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + + // Insert. + + // Get across versions. + + // List. + mock.MockProjects.Objects[*keyGA] = mock.MockProjects.Obj(&ga.Project{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + + // Delete across versions. + + // Delete not found. +} + +func TestRegionBackendServicesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaRegionBackendServices().Get(ctx, *key); err == nil { + t.Errorf("AlphaRegionBackendServices().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.BackendService{} + if err := mock.AlphaRegionBackendServices().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaRegionBackendServices().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaRegionBackendServices().Get(ctx, *key); err != nil { + t.Errorf("AlphaRegionBackendServices().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaRegionBackendServices.Objects[*keyAlpha] = mock.MockAlphaRegionBackendServices.Obj(&alpha.BackendService{Name: keyAlpha.Name}) + want := map[string]bool{ + "key-alpha": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaRegionBackendServices().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaRegionBackendServices().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRegionBackendServices().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaRegionBackendServices().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaRegionBackendServices().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaRegionBackendServices().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestRegionDisksGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyAlpha := meta.RegionalKey("key-alpha", "location") + key = keyAlpha + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.AlphaRegionDisks().Get(ctx, *key); err == nil { + t.Errorf("AlphaRegionDisks().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &alpha.Disk{} + if err := mock.AlphaRegionDisks().Insert(ctx, *keyAlpha, obj); err != nil { + t.Errorf("AlphaRegionDisks().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.AlphaRegionDisks().Get(ctx, *key); err != nil { + t.Errorf("AlphaRegionDisks().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockAlphaRegionDisks.Objects[*keyAlpha] = mock.MockAlphaRegionDisks.Obj(&alpha.Disk{Name: keyAlpha.Name}) + want := map[string]bool{ + "key-alpha": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.AlphaRegionDisks().List(ctx, location, filter.None) + if err != nil { + t.Errorf("AlphaRegionDisks().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRegionDisks().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.AlphaRegionDisks().Delete(ctx, *keyAlpha); err != nil { + t.Errorf("AlphaRegionDisks().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.AlphaRegionDisks().Delete(ctx, *keyAlpha); err == nil { + t.Errorf("AlphaRegionDisks().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestRegionsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Regions().Get(ctx, *key); err == nil { + t.Errorf("Regions().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + + // Get across versions. + + // List. + mock.MockRegions.Objects[*keyGA] = mock.MockRegions.Obj(&ga.Region{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Regions().List(ctx, filter.None) + if err != nil { + t.Errorf("Regions().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRegions().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + + // Delete not found. +} + +func TestRoutesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Routes().Get(ctx, *key); err == nil { + t.Errorf("Routes().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.Route{} + if err := mock.Routes().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("Routes().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.Routes().Get(ctx, *key); err != nil { + t.Errorf("Routes().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockRoutes.Objects[*keyGA] = mock.MockRoutes.Obj(&ga.Route{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Routes().List(ctx, filter.None) + if err != nil { + t.Errorf("Routes().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaRoutes().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.Routes().Delete(ctx, *keyGA); err != nil { + t.Errorf("Routes().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.Routes().Delete(ctx, *keyGA); err == nil { + t.Errorf("Routes().Delete(%v, %v) = nil; want error", ctx, key) + } +} + func TestSslCertificatesGroup(t *testing.T) { t.Parallel() @@ -1686,6 +1453,68 @@ func TestSslCertificatesGroup(t *testing.T) { } } +func TestTargetHttpProxiesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.TargetHttpProxies().Get(ctx, *key); err == nil { + t.Errorf("TargetHttpProxies().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.TargetHttpProxy{} + if err := mock.TargetHttpProxies().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("TargetHttpProxies().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.TargetHttpProxies().Get(ctx, *key); err != nil { + t.Errorf("TargetHttpProxies().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockTargetHttpProxies.Objects[*keyGA] = mock.MockTargetHttpProxies.Obj(&ga.TargetHttpProxy{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.TargetHttpProxies().List(ctx, filter.None) + if err != nil { + t.Errorf("TargetHttpProxies().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaTargetHttpProxies().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.TargetHttpProxies().Delete(ctx, *keyGA); err != nil { + t.Errorf("TargetHttpProxies().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.TargetHttpProxies().Delete(ctx, *keyGA); err == nil { + t.Errorf("TargetHttpProxies().Delete(%v, %v) = nil; want error", ctx, key) + } +} + func TestTargetHttpsProxiesGroup(t *testing.T) { t.Parallel() @@ -1747,3 +1576,174 @@ func TestTargetHttpsProxiesGroup(t *testing.T) { t.Errorf("TargetHttpsProxies().Delete(%v, %v) = nil; want error", ctx, key) } } + +func TestTargetPoolsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.RegionalKey("key-ga", "location") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.TargetPools().Get(ctx, *key); err == nil { + t.Errorf("TargetPools().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.TargetPool{} + if err := mock.TargetPools().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("TargetPools().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.TargetPools().Get(ctx, *key); err != nil { + t.Errorf("TargetPools().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockTargetPools.Objects[*keyGA] = mock.MockTargetPools.Obj(&ga.TargetPool{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.TargetPools().List(ctx, location, filter.None) + if err != nil { + t.Errorf("TargetPools().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaTargetPools().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.TargetPools().Delete(ctx, *keyGA); err != nil { + t.Errorf("TargetPools().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.TargetPools().Delete(ctx, *keyGA); err == nil { + t.Errorf("TargetPools().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestUrlMapsGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.UrlMaps().Get(ctx, *key); err == nil { + t.Errorf("UrlMaps().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + { + obj := &ga.UrlMap{} + if err := mock.UrlMaps().Insert(ctx, *keyGA, obj); err != nil { + t.Errorf("UrlMaps().Insert(%v, %v, %v) = %v; want nil", ctx, key, obj, err) + } + } + + // Get across versions. + if obj, err := mock.UrlMaps().Get(ctx, *key); err != nil { + t.Errorf("UrlMaps().Get(%v, %v) = %v, %v; want nil", ctx, key, obj, err) + } + + // List. + mock.MockUrlMaps.Objects[*keyGA] = mock.MockUrlMaps.Obj(&ga.UrlMap{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.UrlMaps().List(ctx, filter.None) + if err != nil { + t.Errorf("UrlMaps().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaUrlMaps().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + if err := mock.UrlMaps().Delete(ctx, *keyGA); err != nil { + t.Errorf("UrlMaps().Delete(%v, %v) = %v; want nil", ctx, key, err) + } + + // Delete not found. + if err := mock.UrlMaps().Delete(ctx, *keyGA); err == nil { + t.Errorf("UrlMaps().Delete(%v, %v) = nil; want error", ctx, key) + } +} + +func TestZonesGroup(t *testing.T) { + t.Parallel() + + ctx := context.Background() + mock := NewMockGCE() + + var key *meta.Key + keyGA := meta.GlobalKey("key-ga") + key = keyGA + // Ignore unused variables. + _, _, _ = ctx, mock, key + + // Get not found. + if _, err := mock.Zones().Get(ctx, *key); err == nil { + t.Errorf("Zones().Get(%v, %v) = _, nil; want error", ctx, key) + } + + // Insert. + + // Get across versions. + + // List. + mock.MockZones.Objects[*keyGA] = mock.MockZones.Obj(&ga.Zone{Name: keyGA.Name}) + want := map[string]bool{ + "key-ga": true, + } + _ = want // ignore unused variables. + { + objs, err := mock.Zones().List(ctx, filter.None) + if err != nil { + t.Errorf("Zones().List(%v, %v, %v) = %v, %v; want _, nil", ctx, location, filter.None, objs, err) + } else { + got := map[string]bool{} + for _, obj := range objs { + got[obj.Name] = true + } + if !reflect.DeepEqual(got, want) { + t.Errorf("AlphaZones().List(); got %+v, want %+v", got, want) + } + } + } + + // Delete across versions. + + // Delete not found. +} From 3cde2613fff06d1b35739831a1cee62640d80d0e Mon Sep 17 00:00:00 2001 From: Bowei Du Date: Tue, 9 Jan 2018 23:09:08 -0800 Subject: [PATCH 18/18] Fix lint and bazel --- hack/update-cloudprovider-gce.sh | 2 ++ hack/verify-cloudprovider-gce.sh | 1 - pkg/cloudprovider/providers/gce/cloud/gen/BUILD | 5 +---- pkg/cloudprovider/providers/gce/cloud/gen/main.go | 2 +- 4 files changed, 4 insertions(+), 6 deletions(-) diff --git a/hack/update-cloudprovider-gce.sh b/hack/update-cloudprovider-gce.sh index b7d606c95b4..90b8659c563 100755 --- a/hack/update-cloudprovider-gce.sh +++ b/hack/update-cloudprovider-gce.sh @@ -1,4 +1,5 @@ #!/bin/bash + # Copyright 2018 The Kubernetes Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -12,6 +13,7 @@ # 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. + set -o errexit set -o nounset set -o pipefail diff --git a/hack/verify-cloudprovider-gce.sh b/hack/verify-cloudprovider-gce.sh index c7615d36592..1aae5aae42a 100755 --- a/hack/verify-cloudprovider-gce.sh +++ b/hack/verify-cloudprovider-gce.sh @@ -1,5 +1,4 @@ #!/bin/bash -#!/bin/bash # Copyright 2018 The Kubernetes Authors. # diff --git a/pkg/cloudprovider/providers/gce/cloud/gen/BUILD b/pkg/cloudprovider/providers/gce/cloud/gen/BUILD index e196daf2ac8..a3591435fe4 100644 --- a/pkg/cloudprovider/providers/gce/cloud/gen/BUILD +++ b/pkg/cloudprovider/providers/gce/cloud/gen/BUILD @@ -5,10 +5,7 @@ go_library( srcs = ["main.go"], importpath = "k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/gen", visibility = ["//visibility:private"], - deps = [ - "//pkg/cloudprovider/providers/gce/cloud/meta:go_default_library", - "//vendor/github.com/golang/glog:go_default_library", - ], + deps = ["//pkg/cloudprovider/providers/gce/cloud/meta:go_default_library"], ) go_binary( diff --git a/pkg/cloudprovider/providers/gce/cloud/gen/main.go b/pkg/cloudprovider/providers/gce/cloud/gen/main.go index ba0dd9cc2f0..d6e16f16ec4 100644 --- a/pkg/cloudprovider/providers/gce/cloud/gen/main.go +++ b/pkg/cloudprovider/providers/gce/cloud/gen/main.go @@ -1113,7 +1113,7 @@ func Test{{.Service}}Group(t *testing.T) { tmpl := template.Must(template.New("unittest").Parse(text)) // Sort keys so the output will be stable. var keys []string - for k, _ := range meta.AllServicesByGroup { + for k := range meta.AllServicesByGroup { keys = append(keys, k) } sort.Strings(keys)