Merge pull request #58490 from bowei/cp-neg

Automatic merge from submit-queue (batch tested with PRs 57867, 58490, 58502, 58134). If you want to cherry-pick this change to another branch, please follow the instructions <a href="https://github.com/kubernetes/community/blob/master/contributors/devel/cherry-picks.md">here</a>.

GCE: neg to use generated code

GCE: neg to use generated code

```release-note
NONE
```

pkg/cloudprovider/providers/gce/gce_networkendpointgroup.go

@@ -18,8 +18,13 @@ package gce
 
 import (
 	"context"
-	computealpha "google.golang.org/api/compute/v0.alpha"
+	"fmt"
 	"strings"
+
+	computealpha "google.golang.org/api/compute/v0.alpha"
+
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/filter"
+	"k8s.io/kubernetes/pkg/cloudprovider/providers/gce/cloud/meta"
 )
 
 const (
@@ -32,48 +37,45 @@ func newNetworkEndpointGroupMetricContext(request string, zone string) *metricCo
 }
 
 func (gce *GCECloud) GetNetworkEndpointGroup(name string, zone string) (*computealpha.NetworkEndpointGroup, error) {
-	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
-		return nil, err
-	}
 	mc := newNetworkEndpointGroupMetricContext("get", zone)
-	v, err := gce.serviceAlpha.NetworkEndpointGroups.Get(gce.ProjectID(), zone, name).Do()
+	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
+		return nil, mc.Observe(err)
+	}
+	v, err := gce.c.AlphaNetworkEndpointGroups().Get(context.Background(), meta.ZonalKey(name, zone))
 	return v, mc.Observe(err)
 }
 
 func (gce *GCECloud) ListNetworkEndpointGroup(zone string) ([]*computealpha.NetworkEndpointGroup, error) {
-	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
-		return nil, err
-	}
 	mc := newNetworkEndpointGroupMetricContext("list", zone)
-	networkEndpointGroups := []*computealpha.NetworkEndpointGroup{}
+	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
-	err := gce.serviceAlpha.NetworkEndpointGroups.List(gce.ProjectID(), zone).Pages(context.Background(), func(res *computealpha.NetworkEndpointGroupList) error {
+		return nil, mc.Observe(err)
-		networkEndpointGroups = append(networkEndpointGroups, res.Items...)
+	}
-		return nil
+	negs, err := gce.c.AlphaNetworkEndpointGroups().List(context.Background(), zone, filter.None)
-	})
+	return negs, mc.Observe(err)
-	return networkEndpointGroups, mc.Observe(err)
 }
 
+// AggregatedListNetworkEndpointGroup returns a map of zone -> endpoint group.
 func (gce *GCECloud) AggregatedListNetworkEndpointGroup() (map[string][]*computealpha.NetworkEndpointGroup, error) {
-	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
-		return nil, err
-	}
 	mc := newNetworkEndpointGroupMetricContext("aggregated_list", "")
-	zoneNetworkEndpointGroupMap := map[string][]*computealpha.NetworkEndpointGroup{}
+	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
-	err := gce.serviceAlpha.NetworkEndpointGroups.AggregatedList(gce.ProjectID()).Pages(context.Background(), func(res *computealpha.NetworkEndpointGroupAggregatedList) error {
+		return nil, mc.Observe(err)
-		for key, negs := range res.Items {
-			if len(negs.NetworkEndpointGroups) == 0 {
-				continue
 	}
-			// key has the format of "zones/${zone_name}"
+	// TODO: filter for the region the cluster is in.
-			zone := strings.Split(key, "/")[1]
+	all, err := gce.c.AlphaNetworkEndpointGroups().AggregatedList(context.Background(), filter.None)
-			if _, ok := zoneNetworkEndpointGroupMap[zone]; !ok {
+	if err != nil {
-				zoneNetworkEndpointGroupMap[zone] = []*computealpha.NetworkEndpointGroup{}
+		return nil, mc.Observe(err)
 	}
-			zoneNetworkEndpointGroupMap[zone] = append(zoneNetworkEndpointGroupMap[zone], negs.NetworkEndpointGroups...)
+	ret := map[string][]*computealpha.NetworkEndpointGroup{}
+	for key, byZone := range all {
+		// key is "zones/<zone name>"
+		parts := strings.Split(key, "/")
+		if len(parts) != 2 {
+			return nil, mc.Observe(fmt.Errorf("invalid key for AggregatedListNetworkEndpointGroup: %q", key))
 		}
-		return nil
+		zone := parts[1]
-	})
+		ret[zone] = append(ret[zone], byZone...)
-	return zoneNetworkEndpointGroupMap, mc.Observe(err)
+	}
+	return ret, mc.Observe(nil)
 }
 
 func (gce *GCECloud) CreateNetworkEndpointGroup(neg *computealpha.NetworkEndpointGroup, zone string) error {
@@ -81,11 +83,7 @@ func (gce *GCECloud) CreateNetworkEndpointGroup(neg *computealpha.NetworkEndpoin
 		return err
 	}
 	mc := newNetworkEndpointGroupMetricContext("create", zone)
-	op, err := gce.serviceAlpha.NetworkEndpointGroups.Insert(gce.ProjectID(), zone, neg).Do()
+	return mc.Observe(gce.c.AlphaNetworkEndpointGroups().Insert(context.Background(), meta.ZonalKey(neg.Name, zone), neg))
-	if err != nil {
-		return mc.Observe(err)
-	}
-	return gce.waitForZoneOp(op, zone, mc)
 }
 
 func (gce *GCECloud) DeleteNetworkEndpointGroup(name string, zone string) error {
@@ -93,56 +91,43 @@ func (gce *GCECloud) DeleteNetworkEndpointGroup(name string, zone string) error
 		return err
 	}
 	mc := newNetworkEndpointGroupMetricContext("delete", zone)
-	op, err := gce.serviceAlpha.NetworkEndpointGroups.Delete(gce.ProjectID(), zone, name).Do()
+	return mc.Observe(gce.c.AlphaNetworkEndpointGroups().Delete(context.Background(), meta.ZonalKey(name, zone)))
-	if err != nil {
-		return mc.Observe(err)
-	}
-	return gce.waitForZoneOp(op, zone, mc)
 }
 
 func (gce *GCECloud) AttachNetworkEndpoints(name, zone string, endpoints []*computealpha.NetworkEndpoint) error {
-	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
-		return err
-	}
 	mc := newNetworkEndpointGroupMetricContext("attach", zone)
-	op, err := gce.serviceAlpha.NetworkEndpointGroups.AttachNetworkEndpoints(gce.ProjectID(), zone, name, &computealpha.NetworkEndpointGroupsAttachEndpointsRequest{
+	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
-		NetworkEndpoints: endpoints,
-	}).Do()
-	if err != nil {
 		return mc.Observe(err)
 	}
-	return gce.waitForZoneOp(op, zone, mc)
+	req := &computealpha.NetworkEndpointGroupsAttachEndpointsRequest{
+		NetworkEndpoints: endpoints,
+	}
+	return mc.Observe(gce.c.AlphaNetworkEndpointGroups().AttachNetworkEndpoints(context.Background(), meta.ZonalKey(name, zone), req))
 }
 
 func (gce *GCECloud) DetachNetworkEndpoints(name, zone string, endpoints []*computealpha.NetworkEndpoint) error {
-	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
-		return err
-	}
 	mc := newNetworkEndpointGroupMetricContext("detach", zone)
-	op, err := gce.serviceAlpha.NetworkEndpointGroups.DetachNetworkEndpoints(gce.ProjectID(), zone, name, &computealpha.NetworkEndpointGroupsDetachEndpointsRequest{
+	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
-		NetworkEndpoints: endpoints,
-	}).Do()
-	if err != nil {
 		return mc.Observe(err)
 	}
-	return gce.waitForZoneOp(op, zone, mc)
+	req := &computealpha.NetworkEndpointGroupsDetachEndpointsRequest{
+		NetworkEndpoints: endpoints,
+	}
+	return mc.Observe(gce.c.AlphaNetworkEndpointGroups().DetachNetworkEndpoints(context.Background(), meta.ZonalKey(name, zone), req))
 }
 
 func (gce *GCECloud) ListNetworkEndpoints(name, zone string, showHealthStatus bool) ([]*computealpha.NetworkEndpointWithHealthStatus, error) {
+	mc := newNetworkEndpointGroupMetricContext("list_networkendpoints", zone)
 	if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
-		return nil, err
+		return nil, mc.Observe(err)
 	}
 	healthStatus := "SKIP"
 	if showHealthStatus {
 		healthStatus = "SHOW"
 	}
-	mc := newNetworkEndpointGroupMetricContext("list_networkendpoints", zone)
+	req := &computealpha.NetworkEndpointGroupsListEndpointsRequest{
-	networkEndpoints := []*computealpha.NetworkEndpointWithHealthStatus{}
-	err := gce.serviceAlpha.NetworkEndpointGroups.ListNetworkEndpoints(gce.ProjectID(), zone, name, &computealpha.NetworkEndpointGroupsListEndpointsRequest{
 		HealthStatus: healthStatus,
-	}).Pages(context.Background(), func(res *computealpha.NetworkEndpointGroupsListNetworkEndpoints) error {
+	}
-		networkEndpoints = append(networkEndpoints, res.Items...)
+	l, err := gce.c.AlphaNetworkEndpointGroups().ListNetworkEndpoints(context.Background(), meta.ZonalKey(name, zone), req, filter.None)
-		return nil
+	return l, mc.Observe(err)
-	})
-	return networkEndpoints, mc.Observe(err)
 }