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
```
This commit is contained in:
Kubernetes Submit Queue 2018-01-23 00:06:28 -08:00 committed by GitHub
commit 8a05e2d7d4
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

View File

@ -18,8 +18,13 @@ package gce
import ( import (
"context" "context"
computealpha "google.golang.org/api/compute/v0.alpha" "fmt"
"strings" "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 ( const (
@ -32,48 +37,45 @@ func newNetworkEndpointGroupMetricContext(request string, zone string) *metricCo
} }
func (gce *GCECloud) GetNetworkEndpointGroup(name string, zone string) (*computealpha.NetworkEndpointGroup, error) { 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) 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) return v, mc.Observe(err)
} }
func (gce *GCECloud) ListNetworkEndpointGroup(zone string) ([]*computealpha.NetworkEndpointGroup, error) { func (gce *GCECloud) ListNetworkEndpointGroup(zone string) ([]*computealpha.NetworkEndpointGroup, error) {
if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
return nil, err
}
mc := newNetworkEndpointGroupMetricContext("list", zone) 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) { func (gce *GCECloud) AggregatedListNetworkEndpointGroup() (map[string][]*computealpha.NetworkEndpointGroup, error) {
if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
return nil, err
}
mc := newNetworkEndpointGroupMetricContext("aggregated_list", "") 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 { func (gce *GCECloud) CreateNetworkEndpointGroup(neg *computealpha.NetworkEndpointGroup, zone string) error {
@ -81,11 +83,7 @@ func (gce *GCECloud) CreateNetworkEndpointGroup(neg *computealpha.NetworkEndpoin
return err return err
} }
mc := newNetworkEndpointGroupMetricContext("create", zone) 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 { func (gce *GCECloud) DeleteNetworkEndpointGroup(name string, zone string) error {
@ -93,56 +91,43 @@ func (gce *GCECloud) DeleteNetworkEndpointGroup(name string, zone string) error
return err return err
} }
mc := newNetworkEndpointGroupMetricContext("delete", zone) 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 { func (gce *GCECloud) AttachNetworkEndpoints(name, zone string, endpoints []*computealpha.NetworkEndpoint) error {
if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
return err
}
mc := newNetworkEndpointGroupMetricContext("attach", zone) 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 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 { func (gce *GCECloud) DetachNetworkEndpoints(name, zone string, endpoints []*computealpha.NetworkEndpoint) error {
if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
return err
}
mc := newNetworkEndpointGroupMetricContext("detach", zone) 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 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) { func (gce *GCECloud) ListNetworkEndpoints(name, zone string, showHealthStatus bool) ([]*computealpha.NetworkEndpointWithHealthStatus, error) {
mc := newNetworkEndpointGroupMetricContext("list_networkendpoints", zone)
if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil { if err := gce.alphaFeatureEnabled(AlphaFeatureNetworkEndpointGroup); err != nil {
return nil, err return nil, mc.Observe(err)
} }
healthStatus := "SKIP" healthStatus := "SKIP"
if showHealthStatus { if showHealthStatus {
healthStatus = "SHOW" 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, 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)
} }