cloud

package

Go to main page

Versions in this module

v1

v1.33.0

Aug 27, 2024

v1.32.0

Jul 25, 2024

Changes in this version

type AlphaForwardingRules

+ Patch func(context.Context, *meta.Key, *computealpha.ForwardingRule, ...Option) error

type AlphaGlobalForwardingRules

+ Patch func(context.Context, *meta.Key, *computealpha.ForwardingRule, ...Option) error

type BetaForwardingRules

+ Patch func(context.Context, *meta.Key, *computebeta.ForwardingRule, ...Option) error

type BetaGlobalForwardingRules

+ Patch func(context.Context, *meta.Key, *computebeta.ForwardingRule, ...Option) error

type ForwardingRules

+ Patch func(context.Context, *meta.Key, *computega.ForwardingRule, ...Option) error

type GCEAlphaForwardingRules

+ func (g *GCEAlphaForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computealpha.ForwardingRule, ...) error

type GCEAlphaGlobalForwardingRules

+ func (g *GCEAlphaGlobalForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computealpha.ForwardingRule, ...) error

type GCEBetaForwardingRules

+ func (g *GCEBetaForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computebeta.ForwardingRule, ...) error

type GCEBetaGlobalForwardingRules

+ func (g *GCEBetaGlobalForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computebeta.ForwardingRule, ...) error

type GCEForwardingRules

+ func (g *GCEForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computega.ForwardingRule, ...) error

type GCEGlobalForwardingRules

+ func (g *GCEGlobalForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computega.ForwardingRule, ...) error

type GlobalForwardingRules

+ Patch func(context.Context, *meta.Key, *computega.ForwardingRule, ...Option) error

type MockAlphaForwardingRules

+ PatchHook func(context.Context, *meta.Key, *computealpha.ForwardingRule, ...) error

+ func (m *MockAlphaForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computealpha.ForwardingRule, ...) error

type MockAlphaGlobalForwardingRules

+ PatchHook func(context.Context, *meta.Key, *computealpha.ForwardingRule, ...) error

+ func (m *MockAlphaGlobalForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computealpha.ForwardingRule, ...) error

type MockBetaForwardingRules

+ PatchHook func(context.Context, *meta.Key, *computebeta.ForwardingRule, ...) error

+ func (m *MockBetaForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computebeta.ForwardingRule, ...) error

type MockBetaGlobalForwardingRules

+ PatchHook func(context.Context, *meta.Key, *computebeta.ForwardingRule, ...) error

+ func (m *MockBetaGlobalForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computebeta.ForwardingRule, ...) error

type MockForwardingRules

+ PatchHook func(context.Context, *meta.Key, *computega.ForwardingRule, *MockForwardingRules, ...) error

+ func (m *MockForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computega.ForwardingRule, ...) error

type MockGlobalForwardingRules

+ PatchHook func(context.Context, *meta.Key, *computega.ForwardingRule, ...) error

+ func (m *MockGlobalForwardingRules) Patch(ctx context.Context, key *meta.Key, arg0 *computega.ForwardingRule, ...) error

v1.31.0

Jul 10, 2024

v1.30.1

Jun 20, 2024

v1.30.0

Jun 11, 2024

v1.29.0

May 30, 2024

Changes in this version

+ type AlphaRegionNetworkEndpointGroups interface

+ AttachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ DetachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.NetworkEndpointGroup, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, ...) error

+ List func(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointGroup, error)

+ ListNetworkEndpoints func(context.Context, *meta.Key, *filter.F, ...Option) ([]*computealpha.NetworkEndpointWithHealthStatus, error)

+ type BetaRegionNetworkEndpointGroups interface

+ AttachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ DetachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*computebeta.NetworkEndpointGroup, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, ...) error

+ List func(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointGroup, error)

+ ListNetworkEndpoints func(context.Context, *meta.Key, *filter.F, ...Option) ([]*computebeta.NetworkEndpointWithHealthStatus, error)

type Cloud

+ AlphaRegionNetworkEndpointGroups func() AlphaRegionNetworkEndpointGroups

+ BetaRegionNetworkEndpointGroups func() BetaRegionNetworkEndpointGroups

+ RegionNetworkEndpointGroups func() RegionNetworkEndpointGroups

type GCE

+ func (gce *GCE) AlphaRegionNetworkEndpointGroups() AlphaRegionNetworkEndpointGroups

+ func (gce *GCE) BetaRegionNetworkEndpointGroups() BetaRegionNetworkEndpointGroups

+ func (gce *GCE) RegionNetworkEndpointGroups() RegionNetworkEndpointGroups

+ type GCEAlphaRegionNetworkEndpointGroups struct

+ func (g *GCEAlphaRegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEAlphaRegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *GCEAlphaRegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEAlphaRegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.NetworkEndpointGroup, error)

+ func (g *GCEAlphaRegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, ...) error

+ func (g *GCEAlphaRegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointGroup, error)

+ func (g *GCEAlphaRegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointWithHealthStatus, error)

+ type GCEBetaRegionNetworkEndpointGroups struct

+ func (g *GCEBetaRegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEBetaRegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *GCEBetaRegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEBetaRegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computebeta.NetworkEndpointGroup, error)

+ func (g *GCEBetaRegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, ...) error

+ func (g *GCEBetaRegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointGroup, error)

+ func (g *GCEBetaRegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointWithHealthStatus, error)

+ type GCERegionNetworkEndpointGroups struct

+ func (g *GCERegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCERegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *GCERegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCERegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.NetworkEndpointGroup, error)

+ func (g *GCERegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, ...) error

+ func (g *GCERegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointGroup, error)

+ func (g *GCERegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointWithHealthStatus, error)

+ type MockAlphaRegionNetworkEndpointGroups struct

+ AttachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionNetworkEndpointGroups, ...) (bool, error)

+ DetachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionNetworkEndpointGroups, ...) (bool, *computealpha.NetworkEndpointGroup, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*computealpha.NetworkEndpointGroup, error)

+ ListNetworkEndpointsHook func(context.Context, *meta.Key, *filter.F, *MockAlphaRegionNetworkEndpointGroups, ...) ([]*computealpha.NetworkEndpointWithHealthStatus, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionNetworkEndpointGroupsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAlphaRegionNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockRegionNetworkEndpointGroupsObj) *MockAlphaRegionNetworkEndpointGroups

+ func (m *MockAlphaRegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockAlphaRegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockAlphaRegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockAlphaRegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.NetworkEndpointGroup, error)

+ func (m *MockAlphaRegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, ...) error

+ func (m *MockAlphaRegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointGroup, error)

+ func (m *MockAlphaRegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointWithHealthStatus, error)

+ func (m *MockAlphaRegionNetworkEndpointGroups) Obj(o *computealpha.NetworkEndpointGroup) *MockRegionNetworkEndpointGroupsObj

+ type MockBetaRegionNetworkEndpointGroups struct

+ AttachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionNetworkEndpointGroups, ...) (bool, error)

+ DetachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionNetworkEndpointGroups, ...) (bool, *computebeta.NetworkEndpointGroup, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*computebeta.NetworkEndpointGroup, error)

+ ListNetworkEndpointsHook func(context.Context, *meta.Key, *filter.F, *MockBetaRegionNetworkEndpointGroups, ...) ([]*computebeta.NetworkEndpointWithHealthStatus, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionNetworkEndpointGroupsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaRegionNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockRegionNetworkEndpointGroupsObj) *MockBetaRegionNetworkEndpointGroups

+ func (m *MockBetaRegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockBetaRegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockBetaRegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockBetaRegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computebeta.NetworkEndpointGroup, error)

+ func (m *MockBetaRegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, ...) error

+ func (m *MockBetaRegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointGroup, error)

+ func (m *MockBetaRegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointWithHealthStatus, error)

+ func (m *MockBetaRegionNetworkEndpointGroups) Obj(o *computebeta.NetworkEndpointGroup) *MockRegionNetworkEndpointGroupsObj

type MockGCE

+ MockAlphaRegionNetworkEndpointGroups *MockAlphaRegionNetworkEndpointGroups

+ MockBetaRegionNetworkEndpointGroups *MockBetaRegionNetworkEndpointGroups

+ MockRegionNetworkEndpointGroups *MockRegionNetworkEndpointGroups

+ func (mock *MockGCE) AlphaRegionNetworkEndpointGroups() AlphaRegionNetworkEndpointGroups

+ func (mock *MockGCE) BetaRegionNetworkEndpointGroups() BetaRegionNetworkEndpointGroups

+ func (mock *MockGCE) RegionNetworkEndpointGroups() RegionNetworkEndpointGroups

+ type MockRegionNetworkEndpointGroups struct

+ AttachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRegionNetworkEndpointGroups, ...) (bool, error)

+ DetachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRegionNetworkEndpointGroups, ...) (bool, *computega.NetworkEndpointGroup, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*computega.NetworkEndpointGroup, error)

+ ListNetworkEndpointsHook func(context.Context, *meta.Key, *filter.F, *MockRegionNetworkEndpointGroups, ...) ([]*computega.NetworkEndpointWithHealthStatus, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionNetworkEndpointGroupsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockRegionNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockRegionNetworkEndpointGroupsObj) *MockRegionNetworkEndpointGroups

+ func (m *MockRegionNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockRegionNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockRegionNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockRegionNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.NetworkEndpointGroup, error)

+ func (m *MockRegionNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, ...) error

+ func (m *MockRegionNetworkEndpointGroups) List(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointGroup, error)

+ func (m *MockRegionNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointWithHealthStatus, error)

+ func (m *MockRegionNetworkEndpointGroups) Obj(o *computega.NetworkEndpointGroup) *MockRegionNetworkEndpointGroupsObj

+ type MockRegionNetworkEndpointGroupsObj struct

+ Obj interface{}

+ func (m *MockRegionNetworkEndpointGroupsObj) ToAlpha() *computealpha.NetworkEndpointGroup

+ func (m *MockRegionNetworkEndpointGroupsObj) ToBeta() *computebeta.NetworkEndpointGroup

+ func (m *MockRegionNetworkEndpointGroupsObj) ToGA() *computega.NetworkEndpointGroup

+ type RegionNetworkEndpointGroups interface

+ AttachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ DetachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*computega.NetworkEndpointGroup, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, ...) error

+ List func(ctx context.Context, region string, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointGroup, error)

+ ListNetworkEndpoints func(context.Context, *meta.Key, *filter.F, ...Option) ([]*computega.NetworkEndpointWithHealthStatus, error)

type ResourceID

+ func NewRegionNetworkEndpointGroupsResourceID(project, region, name string) *ResourceID

v1.28.0

May 9, 2024

Changes in this version

+ type CompositeRateLimiter struct

+ func NewCompositeRateLimiter(defaultRL RateLimiter) *CompositeRateLimiter

+ func (*CompositeRateLimiter) Observe(context.Context, error, *RateLimitKey)

+ func (c *CompositeRateLimiter) Accept(ctx context.Context, rlk *RateLimitKey) error

+ func (c *CompositeRateLimiter) Register(service, operation string, rl RateLimiter)

+ type TickerRateLimiter struct

+ func NewTickerRateLimiter(limit int, interval time.Duration) *TickerRateLimiter

+ func (*TickerRateLimiter) Observe(context.Context, error, *RateLimitKey)

+ func (t *TickerRateLimiter) Accept(ctx context.Context, rlk *RateLimitKey) error

v1.27.0

Feb 26, 2024

Changes in this version

type AlphaRegionBackendServices

+ SetSecurityPolicy func(context.Context, *meta.Key, *computealpha.SecurityPolicyReference, ...Option) error

type BetaRegionBackendServices

+ SetSecurityPolicy func(context.Context, *meta.Key, *computebeta.SecurityPolicyReference, ...Option) error

type GCEAlphaRegionBackendServices

+ func (g *GCEAlphaRegionBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *computealpha.SecurityPolicyReference, ...) error

type GCEBetaRegionBackendServices

+ func (g *GCEBetaRegionBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *computebeta.SecurityPolicyReference, ...) error

type GCERegionBackendServices

+ func (g *GCERegionBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *computega.SecurityPolicyReference, ...) error

type MockAlphaRegionBackendServices

+ SetSecurityPolicyHook func(context.Context, *meta.Key, *computealpha.SecurityPolicyReference, ...) error

+ func (m *MockAlphaRegionBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *computealpha.SecurityPolicyReference, ...) error

type MockBetaRegionBackendServices

+ SetSecurityPolicyHook func(context.Context, *meta.Key, *computebeta.SecurityPolicyReference, ...) error

+ func (m *MockBetaRegionBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *computebeta.SecurityPolicyReference, ...) error

type MockRegionBackendServices

+ SetSecurityPolicyHook func(context.Context, *meta.Key, *computega.SecurityPolicyReference, ...) error

+ func (m *MockRegionBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *computega.SecurityPolicyReference, ...) error

type RegionBackendServices

+ SetSecurityPolicy func(context.Context, *meta.Key, *computega.SecurityPolicyReference, ...Option) error

v1.26.0

Jan 26, 2024

v1.25.0

Nov 30, 2023

Changes in this version

+ func SelfLinkWithGroup(apiGroup meta.APIGroup, ver meta.Version, project, resource string, ...) string

+ type AlphaGlobalNetworkEndpointGroups interface

+ AttachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ DetachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.NetworkEndpointGroup, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, ...) error

+ List func(ctx context.Context, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointGroup, error)

+ ListNetworkEndpoints func(context.Context, *meta.Key, *filter.F, ...Option) ([]*computealpha.NetworkEndpointWithHealthStatus, error)

type AlphaRegionTargetHttpsProxies

+ Patch func(context.Context, *meta.Key, *computealpha.TargetHttpsProxy, ...Option) error

+ type BetaGlobalNetworkEndpointGroups interface

+ AttachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ DetachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*computebeta.NetworkEndpointGroup, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, ...) error

+ List func(ctx context.Context, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointGroup, error)

+ ListNetworkEndpoints func(context.Context, *meta.Key, *filter.F, ...Option) ([]*computebeta.NetworkEndpointWithHealthStatus, error)

+ type BetaMeshes interface

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesbeta.Mesh, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *networkservicesbeta.Mesh, ...) error

+ List func(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesbeta.Mesh, error)

+ Patch func(context.Context, *meta.Key, *networkservicesbeta.Mesh, ...Option) error

type BetaRegionTargetHttpsProxies

+ Patch func(context.Context, *meta.Key, *computebeta.TargetHttpsProxy, ...Option) error

+ type BetaTcpRoutes interface

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesbeta.TcpRoute, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *networkservicesbeta.TcpRoute, ...) error

+ List func(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesbeta.TcpRoute, error)

+ Patch func(context.Context, *meta.Key, *networkservicesbeta.TcpRoute, ...Option) error

type Cloud

+ AlphaGlobalNetworkEndpointGroups func() AlphaGlobalNetworkEndpointGroups

+ BetaGlobalNetworkEndpointGroups func() BetaGlobalNetworkEndpointGroups

+ BetaMeshes func() BetaMeshes

+ BetaTcpRoutes func() BetaTcpRoutes

+ GlobalNetworkEndpointGroups func() GlobalNetworkEndpointGroups

+ Meshes func() Meshes

+ RegionSslPolicies func() RegionSslPolicies

+ TcpRoutes func() TcpRoutes

type GCE

+ func (gce *GCE) AlphaGlobalNetworkEndpointGroups() AlphaGlobalNetworkEndpointGroups

+ func (gce *GCE) BetaGlobalNetworkEndpointGroups() BetaGlobalNetworkEndpointGroups

+ func (gce *GCE) BetaMeshes() BetaMeshes

+ func (gce *GCE) BetaTcpRoutes() BetaTcpRoutes

+ func (gce *GCE) GlobalNetworkEndpointGroups() GlobalNetworkEndpointGroups

+ func (gce *GCE) Meshes() Meshes

+ func (gce *GCE) RegionSslPolicies() RegionSslPolicies

+ func (gce *GCE) TcpRoutes() TcpRoutes

+ type GCEAlphaGlobalNetworkEndpointGroups struct

+ func (g *GCEAlphaGlobalNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEAlphaGlobalNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *GCEAlphaGlobalNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEAlphaGlobalNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.NetworkEndpointGroup, error)

+ func (g *GCEAlphaGlobalNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, ...) error

+ func (g *GCEAlphaGlobalNetworkEndpointGroups) List(ctx context.Context, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointGroup, error)

+ func (g *GCEAlphaGlobalNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointWithHealthStatus, error)

type GCEAlphaRegionTargetHttpsProxies

+ func (g *GCEAlphaRegionTargetHttpsProxies) Patch(ctx context.Context, key *meta.Key, arg0 *computealpha.TargetHttpsProxy, ...) error

+ type GCEBetaGlobalNetworkEndpointGroups struct

+ func (g *GCEBetaGlobalNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEBetaGlobalNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *GCEBetaGlobalNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEBetaGlobalNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computebeta.NetworkEndpointGroup, error)

+ func (g *GCEBetaGlobalNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, ...) error

+ func (g *GCEBetaGlobalNetworkEndpointGroups) List(ctx context.Context, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointGroup, error)

+ func (g *GCEBetaGlobalNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointWithHealthStatus, error)

type GCEBetaRegionTargetHttpsProxies

+ func (g *GCEBetaRegionTargetHttpsProxies) Patch(ctx context.Context, key *meta.Key, arg0 *computebeta.TargetHttpsProxy, ...) error

+ type GCEGlobalNetworkEndpointGroups struct

+ func (g *GCEGlobalNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEGlobalNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *GCEGlobalNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEGlobalNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.NetworkEndpointGroup, error)

+ func (g *GCEGlobalNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, ...) error

+ func (g *GCEGlobalNetworkEndpointGroups) List(ctx context.Context, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointGroup, error)

+ func (g *GCEGlobalNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointWithHealthStatus, error)

+ type GCERegionSslPolicies struct

+ func (g *GCERegionSslPolicies) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *GCERegionSslPolicies) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.SslPolicy, error)

+ func (g *GCERegionSslPolicies) Insert(ctx context.Context, key *meta.Key, obj *computega.SslPolicy, ...) error

type GCERegionTargetHttpsProxies

+ func (g *GCERegionTargetHttpsProxies) Patch(ctx context.Context, key *meta.Key, arg0 *computega.TargetHttpsProxy, ...) error

+ type GlobalNetworkEndpointGroups interface

+ AttachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ DetachNetworkEndpoints func(context.Context, *meta.Key, ...) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*computega.NetworkEndpointGroup, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, ...) error

+ List func(ctx context.Context, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointGroup, error)

+ ListNetworkEndpoints func(context.Context, *meta.Key, *filter.F, ...Option) ([]*computega.NetworkEndpointWithHealthStatus, error)

+ type Meshes interface

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesga.Mesh, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *networkservicesga.Mesh, ...) error

+ List func(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesga.Mesh, error)

+ Patch func(context.Context, *meta.Key, *networkservicesga.Mesh, ...Option) error

+ type MockAlphaGlobalNetworkEndpointGroups struct

+ AttachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaGlobalNetworkEndpointGroups, ...) (bool, error)

+ DetachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaGlobalNetworkEndpointGroups, ...) (bool, *computealpha.NetworkEndpointGroup, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaGlobalNetworkEndpointGroups, ...) (bool, []*computealpha.NetworkEndpointGroup, error)

+ ListNetworkEndpointsHook func(context.Context, *meta.Key, *filter.F, *MockAlphaGlobalNetworkEndpointGroups, ...) ([]*computealpha.NetworkEndpointWithHealthStatus, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockGlobalNetworkEndpointGroupsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAlphaGlobalNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockGlobalNetworkEndpointGroupsObj) *MockAlphaGlobalNetworkEndpointGroups

+ func (m *MockAlphaGlobalNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockAlphaGlobalNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockAlphaGlobalNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockAlphaGlobalNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computealpha.NetworkEndpointGroup, error)

+ func (m *MockAlphaGlobalNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computealpha.NetworkEndpointGroup, ...) error

+ func (m *MockAlphaGlobalNetworkEndpointGroups) List(ctx context.Context, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointGroup, error)

+ func (m *MockAlphaGlobalNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computealpha.NetworkEndpointWithHealthStatus, error)

+ func (m *MockAlphaGlobalNetworkEndpointGroups) Obj(o *computealpha.NetworkEndpointGroup) *MockGlobalNetworkEndpointGroupsObj

type MockAlphaRegionTargetHttpsProxies

+ PatchHook func(context.Context, *meta.Key, *computealpha.TargetHttpsProxy, ...) error

+ func (m *MockAlphaRegionTargetHttpsProxies) Patch(ctx context.Context, key *meta.Key, arg0 *computealpha.TargetHttpsProxy, ...) error

+ type MockBetaGlobalNetworkEndpointGroups struct

+ AttachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaGlobalNetworkEndpointGroups, ...) (bool, error)

+ DetachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaGlobalNetworkEndpointGroups, ...) (bool, *computebeta.NetworkEndpointGroup, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaGlobalNetworkEndpointGroups, ...) (bool, []*computebeta.NetworkEndpointGroup, error)

+ ListNetworkEndpointsHook func(context.Context, *meta.Key, *filter.F, *MockBetaGlobalNetworkEndpointGroups, ...) ([]*computebeta.NetworkEndpointWithHealthStatus, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockGlobalNetworkEndpointGroupsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaGlobalNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockGlobalNetworkEndpointGroupsObj) *MockBetaGlobalNetworkEndpointGroups

+ func (m *MockBetaGlobalNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockBetaGlobalNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockBetaGlobalNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockBetaGlobalNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computebeta.NetworkEndpointGroup, error)

+ func (m *MockBetaGlobalNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computebeta.NetworkEndpointGroup, ...) error

+ func (m *MockBetaGlobalNetworkEndpointGroups) List(ctx context.Context, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointGroup, error)

+ func (m *MockBetaGlobalNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computebeta.NetworkEndpointWithHealthStatus, error)

+ func (m *MockBetaGlobalNetworkEndpointGroups) Obj(o *computebeta.NetworkEndpointGroup) *MockGlobalNetworkEndpointGroupsObj

+ type MockBetaMeshes struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaMeshes, options ...Option) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaMeshes, options ...Option) (bool, *networkservicesbeta.Mesh, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *networkservicesbeta.Mesh, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaMeshes, options ...Option) (bool, []*networkservicesbeta.Mesh, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockMeshesObj

+ PatchHook func(context.Context, *meta.Key, *networkservicesbeta.Mesh, *MockBetaMeshes, ...) error

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaMeshes(pr ProjectRouter, objs map[meta.Key]*MockMeshesObj) *MockBetaMeshes

+ func (m *MockBetaMeshes) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockBetaMeshes) Get(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesbeta.Mesh, error)

+ func (m *MockBetaMeshes) Insert(ctx context.Context, key *meta.Key, obj *networkservicesbeta.Mesh, ...) error

+ func (m *MockBetaMeshes) List(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesbeta.Mesh, error)

+ func (m *MockBetaMeshes) Obj(o *networkservicesbeta.Mesh) *MockMeshesObj

+ func (m *MockBetaMeshes) Patch(ctx context.Context, key *meta.Key, arg0 *networkservicesbeta.Mesh, ...) error

type MockBetaRegionTargetHttpsProxies

+ PatchHook func(context.Context, *meta.Key, *computebeta.TargetHttpsProxy, ...) error

+ func (m *MockBetaRegionTargetHttpsProxies) Patch(ctx context.Context, key *meta.Key, arg0 *computebeta.TargetHttpsProxy, ...) error

+ type MockBetaTcpRoutes struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaTcpRoutes, options ...Option) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaTcpRoutes, options ...Option) (bool, *networkservicesbeta.TcpRoute, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *networkservicesbeta.TcpRoute, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaTcpRoutes, options ...Option) (bool, []*networkservicesbeta.TcpRoute, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTcpRoutesObj

+ PatchHook func(context.Context, *meta.Key, *networkservicesbeta.TcpRoute, *MockBetaTcpRoutes, ...) error

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaTcpRoutes(pr ProjectRouter, objs map[meta.Key]*MockTcpRoutesObj) *MockBetaTcpRoutes

+ func (m *MockBetaTcpRoutes) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockBetaTcpRoutes) Get(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesbeta.TcpRoute, error)

+ func (m *MockBetaTcpRoutes) Insert(ctx context.Context, key *meta.Key, obj *networkservicesbeta.TcpRoute, ...) error

+ func (m *MockBetaTcpRoutes) List(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesbeta.TcpRoute, error)

+ func (m *MockBetaTcpRoutes) Obj(o *networkservicesbeta.TcpRoute) *MockTcpRoutesObj

+ func (m *MockBetaTcpRoutes) Patch(ctx context.Context, key *meta.Key, arg0 *networkservicesbeta.TcpRoute, ...) error

type MockGCE

+ MockAlphaGlobalNetworkEndpointGroups *MockAlphaGlobalNetworkEndpointGroups

+ MockBetaGlobalNetworkEndpointGroups *MockBetaGlobalNetworkEndpointGroups

+ MockBetaMeshes *MockBetaMeshes

+ MockBetaTcpRoutes *MockBetaTcpRoutes

+ MockGlobalNetworkEndpointGroups *MockGlobalNetworkEndpointGroups

+ MockMeshes *MockMeshes

+ MockRegionSslPolicies *MockRegionSslPolicies

+ MockTcpRoutes *MockTcpRoutes

+ func (mock *MockGCE) AlphaGlobalNetworkEndpointGroups() AlphaGlobalNetworkEndpointGroups

+ func (mock *MockGCE) BetaGlobalNetworkEndpointGroups() BetaGlobalNetworkEndpointGroups

+ func (mock *MockGCE) BetaMeshes() BetaMeshes

+ func (mock *MockGCE) BetaTcpRoutes() BetaTcpRoutes

+ func (mock *MockGCE) GlobalNetworkEndpointGroups() GlobalNetworkEndpointGroups

+ func (mock *MockGCE) Meshes() Meshes

+ func (mock *MockGCE) RegionSslPolicies() RegionSslPolicies

+ func (mock *MockGCE) TcpRoutes() TcpRoutes

+ type MockGlobalNetworkEndpointGroups struct

+ AttachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockGlobalNetworkEndpointGroups, ...) (bool, error)

+ DetachNetworkEndpointsHook func(context.Context, *meta.Key, ...) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockGlobalNetworkEndpointGroups, ...) (bool, *computega.NetworkEndpointGroup, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockGlobalNetworkEndpointGroups, ...) (bool, []*computega.NetworkEndpointGroup, error)

+ ListNetworkEndpointsHook func(context.Context, *meta.Key, *filter.F, *MockGlobalNetworkEndpointGroups, ...) ([]*computega.NetworkEndpointWithHealthStatus, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockGlobalNetworkEndpointGroupsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockGlobalNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockGlobalNetworkEndpointGroupsObj) *MockGlobalNetworkEndpointGroups

+ func (m *MockGlobalNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockGlobalNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockGlobalNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockGlobalNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.NetworkEndpointGroup, error)

+ func (m *MockGlobalNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *computega.NetworkEndpointGroup, ...) error

+ func (m *MockGlobalNetworkEndpointGroups) List(ctx context.Context, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointGroup, error)

+ func (m *MockGlobalNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, fl *filter.F, options ...Option) ([]*computega.NetworkEndpointWithHealthStatus, error)

+ func (m *MockGlobalNetworkEndpointGroups) Obj(o *computega.NetworkEndpointGroup) *MockGlobalNetworkEndpointGroupsObj

+ type MockGlobalNetworkEndpointGroupsObj struct

+ Obj interface{}

+ func (m *MockGlobalNetworkEndpointGroupsObj) ToAlpha() *computealpha.NetworkEndpointGroup

+ func (m *MockGlobalNetworkEndpointGroupsObj) ToBeta() *computebeta.NetworkEndpointGroup

+ func (m *MockGlobalNetworkEndpointGroupsObj) ToGA() *computega.NetworkEndpointGroup

+ type MockMeshes struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockMeshes, options ...Option) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockMeshes, options ...Option) (bool, *networkservicesga.Mesh, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *networkservicesga.Mesh, m *MockMeshes, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockMeshes, options ...Option) (bool, []*networkservicesga.Mesh, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockMeshesObj

+ PatchHook func(context.Context, *meta.Key, *networkservicesga.Mesh, *MockMeshes, ...Option) error

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockMeshes(pr ProjectRouter, objs map[meta.Key]*MockMeshesObj) *MockMeshes

+ func (m *MockMeshes) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockMeshes) Get(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesga.Mesh, error)

+ func (m *MockMeshes) Insert(ctx context.Context, key *meta.Key, obj *networkservicesga.Mesh, ...) error

+ func (m *MockMeshes) List(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesga.Mesh, error)

+ func (m *MockMeshes) Obj(o *networkservicesga.Mesh) *MockMeshesObj

+ func (m *MockMeshes) Patch(ctx context.Context, key *meta.Key, arg0 *networkservicesga.Mesh, ...) error

+ type MockMeshesObj struct

+ Obj interface{}

+ func (m *MockMeshesObj) ToBeta() *networkservicesbeta.Mesh

+ func (m *MockMeshesObj) ToGA() *networkservicesga.Mesh

+ type MockRegionSslPolicies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRegionSslPolicies, ...) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRegionSslPolicies, ...) (bool, *computega.SslPolicy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *computega.SslPolicy, ...) (bool, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionSslPoliciesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockRegionSslPolicies(pr ProjectRouter, objs map[meta.Key]*MockRegionSslPoliciesObj) *MockRegionSslPolicies

+ func (m *MockRegionSslPolicies) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockRegionSslPolicies) Get(ctx context.Context, key *meta.Key, options ...Option) (*computega.SslPolicy, error)

+ func (m *MockRegionSslPolicies) Insert(ctx context.Context, key *meta.Key, obj *computega.SslPolicy, ...) error

+ func (m *MockRegionSslPolicies) Obj(o *computega.SslPolicy) *MockRegionSslPoliciesObj

+ type MockRegionSslPoliciesObj struct

+ Obj interface{}

+ func (m *MockRegionSslPoliciesObj) ToGA() *computega.SslPolicy

type MockRegionTargetHttpsProxies

+ PatchHook func(context.Context, *meta.Key, *computega.TargetHttpsProxy, ...) error

+ func (m *MockRegionTargetHttpsProxies) Patch(ctx context.Context, key *meta.Key, arg0 *computega.TargetHttpsProxy, ...) error

+ type MockTcpRoutes struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockTcpRoutes, options ...Option) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockTcpRoutes, options ...Option) (bool, *networkservicesga.TcpRoute, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *networkservicesga.TcpRoute, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockTcpRoutes, options ...Option) (bool, []*networkservicesga.TcpRoute, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTcpRoutesObj

+ PatchHook func(context.Context, *meta.Key, *networkservicesga.TcpRoute, *MockTcpRoutes, ...) error

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockTcpRoutes(pr ProjectRouter, objs map[meta.Key]*MockTcpRoutesObj) *MockTcpRoutes

+ func (m *MockTcpRoutes) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (m *MockTcpRoutes) Get(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesga.TcpRoute, error)

+ func (m *MockTcpRoutes) Insert(ctx context.Context, key *meta.Key, obj *networkservicesga.TcpRoute, ...) error

+ func (m *MockTcpRoutes) List(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesga.TcpRoute, error)

+ func (m *MockTcpRoutes) Obj(o *networkservicesga.TcpRoute) *MockTcpRoutesObj

+ func (m *MockTcpRoutes) Patch(ctx context.Context, key *meta.Key, arg0 *networkservicesga.TcpRoute, ...) error

+ type MockTcpRoutesObj struct

+ Obj interface{}

+ func (m *MockTcpRoutesObj) ToBeta() *networkservicesbeta.TcpRoute

+ func (m *MockTcpRoutesObj) ToGA() *networkservicesga.TcpRoute

+ type Option interface

+ func ForceProjectID(projectID string) Option

+ type RegionSslPolicies interface

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*computega.SslPolicy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *computega.SslPolicy, ...) error

type RegionTargetHttpsProxies

+ Patch func(context.Context, *meta.Key, *computega.TargetHttpsProxy, ...Option) error

type ResourceID

+ APIGroup meta.APIGroup

+ func NewGlobalNetworkEndpointGroupsResourceID(project, name string) *ResourceID

+ func NewMeshesResourceID(project, name string) *ResourceID

+ func NewRegionSslPoliciesResourceID(project, region, name string) *ResourceID

+ func NewTcpRoutesResourceID(project, name string) *ResourceID

type ResourceMapKey

+ APIGroup meta.APIGroup

type Service

+ NetworkServicesBeta *networkservicesbeta.ProjectsLocationsService

+ NetworkServicesGA *networkservicesga.ProjectsLocationsService

+ func NewService(ctx context.Context, client *http.Client, pr ProjectRouter, rl RateLimiter) (*Service, error)

+ type TDBetaMeshes struct

+ func (g *TDBetaMeshes) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *TDBetaMeshes) Get(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesbeta.Mesh, error)

+ func (g *TDBetaMeshes) Insert(ctx context.Context, key *meta.Key, obj *networkservicesbeta.Mesh, ...) error

+ func (g *TDBetaMeshes) List(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesbeta.Mesh, error)

+ func (g *TDBetaMeshes) Patch(ctx context.Context, key *meta.Key, arg0 *networkservicesbeta.Mesh, ...) error

+ type TDBetaTcpRoutes struct

+ func (g *TDBetaTcpRoutes) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *TDBetaTcpRoutes) Get(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesbeta.TcpRoute, error)

+ func (g *TDBetaTcpRoutes) Insert(ctx context.Context, key *meta.Key, obj *networkservicesbeta.TcpRoute, ...) error

+ func (g *TDBetaTcpRoutes) List(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesbeta.TcpRoute, error)

+ func (g *TDBetaTcpRoutes) Patch(ctx context.Context, key *meta.Key, arg0 *networkservicesbeta.TcpRoute, ...) error

+ type TDMeshes struct

+ func (g *TDMeshes) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *TDMeshes) Get(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesga.Mesh, error)

+ func (g *TDMeshes) Insert(ctx context.Context, key *meta.Key, obj *networkservicesga.Mesh, ...) error

+ func (g *TDMeshes) List(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesga.Mesh, error)

+ func (g *TDMeshes) Patch(ctx context.Context, key *meta.Key, arg0 *networkservicesga.Mesh, ...) error

+ type TDTcpRoutes struct

+ func (g *TDTcpRoutes) Delete(ctx context.Context, key *meta.Key, options ...Option) error

+ func (g *TDTcpRoutes) Get(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesga.TcpRoute, error)

+ func (g *TDTcpRoutes) Insert(ctx context.Context, key *meta.Key, obj *networkservicesga.TcpRoute, ...) error

+ func (g *TDTcpRoutes) List(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesga.TcpRoute, error)

+ func (g *TDTcpRoutes) Patch(ctx context.Context, key *meta.Key, arg0 *networkservicesga.TcpRoute, ...) error

+ type TcpRoutes interface

+ Delete func(ctx context.Context, key *meta.Key, options ...Option) error

+ Get func(ctx context.Context, key *meta.Key, options ...Option) (*networkservicesga.TcpRoute, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *networkservicesga.TcpRoute, ...) error

+ List func(ctx context.Context, fl *filter.F, options ...Option) ([]*networkservicesga.TcpRoute, error)

+ Patch func(context.Context, *meta.Key, *networkservicesga.TcpRoute, ...Option) error

v1.24.0

May 30, 2023

Changes in this version

type ResourceID

+ func (r *ResourceID) MapKey() ResourceMapKey

+ func (r *ResourceID) String() string

+ type ResourceMapKey struct

+ Name string

+ ProjectID string

+ Region string

+ Resource string

+ Zone string

+ func (rk ResourceMapKey) ToID() *ResourceID

v1.23.0

Mar 28, 2023

Changes in this version

+ var OperationsUseWait = true

type Cloud

+ InstanceGroupManagers func() InstanceGroupManagers

+ InstanceTemplates func() InstanceTemplates

type GCE

+ func (gce *GCE) InstanceGroupManagers() InstanceGroupManagers

+ func (gce *GCE) InstanceTemplates() InstanceTemplates

+ type GCEInstanceGroupManagers struct

+ func (g *GCEInstanceGroupManagers) CreateInstances(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEInstanceGroupManagers) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEInstanceGroupManagers) DeleteInstances(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEInstanceGroupManagers) Get(ctx context.Context, key *meta.Key) (*ga.InstanceGroupManager, error)

+ func (g *GCEInstanceGroupManagers) Insert(ctx context.Context, key *meta.Key, obj *ga.InstanceGroupManager) error

+ func (g *GCEInstanceGroupManagers) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroupManager, error)

+ func (g *GCEInstanceGroupManagers) Resize(ctx context.Context, key *meta.Key, arg0 int64) error

+ func (g *GCEInstanceGroupManagers) SetInstanceTemplate(ctx context.Context, key *meta.Key, ...) error

+ type GCEInstanceTemplates struct

+ func (g *GCEInstanceTemplates) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEInstanceTemplates) Get(ctx context.Context, key *meta.Key) (*ga.InstanceTemplate, error)

+ func (g *GCEInstanceTemplates) Insert(ctx context.Context, key *meta.Key, obj *ga.InstanceTemplate) error

+ func (g *GCEInstanceTemplates) List(ctx context.Context, fl *filter.F) ([]*ga.InstanceTemplate, error)

+ type InstanceGroupManagers interface

+ CreateInstances func(context.Context, *meta.Key, *ga.InstanceGroupManagersCreateInstancesRequest) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ DeleteInstances func(context.Context, *meta.Key, *ga.InstanceGroupManagersDeleteInstancesRequest) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.InstanceGroupManager, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.InstanceGroupManager) error

+ List func(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroupManager, error)

+ Resize func(context.Context, *meta.Key, int64) error

+ SetInstanceTemplate func(context.Context, *meta.Key, ...) error

+ type InstanceTemplates interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.InstanceTemplate, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.InstanceTemplate) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.InstanceTemplate, error)

type MockGCE

+ MockInstanceGroupManagers *MockInstanceGroupManagers

+ MockInstanceTemplates *MockInstanceTemplates

+ func (mock *MockGCE) InstanceGroupManagers() InstanceGroupManagers

+ func (mock *MockGCE) InstanceTemplates() InstanceTemplates

+ type MockInstanceGroupManagers struct

+ CreateInstancesHook func(context.Context, *meta.Key, *ga.InstanceGroupManagersCreateInstancesRequest, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockInstanceGroupManagers) (bool, error)

+ DeleteInstancesHook func(context.Context, *meta.Key, *ga.InstanceGroupManagersDeleteInstancesRequest, ...) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockInstanceGroupManagers) (bool, *ga.InstanceGroupManager, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.InstanceGroupManager, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, zone string, fl *filter.F, m *MockInstanceGroupManagers) (bool, []*ga.InstanceGroupManager, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockInstanceGroupManagersObj

+ ProjectRouter ProjectRouter

+ ResizeHook func(context.Context, *meta.Key, int64, *MockInstanceGroupManagers) error

+ SetInstanceTemplateHook func(context.Context, *meta.Key, ...) error

+ X interface{}

+ func NewMockInstanceGroupManagers(pr ProjectRouter, objs map[meta.Key]*MockInstanceGroupManagersObj) *MockInstanceGroupManagers

+ func (m *MockInstanceGroupManagers) CreateInstances(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockInstanceGroupManagers) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockInstanceGroupManagers) DeleteInstances(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockInstanceGroupManagers) Get(ctx context.Context, key *meta.Key) (*ga.InstanceGroupManager, error)

+ func (m *MockInstanceGroupManagers) Insert(ctx context.Context, key *meta.Key, obj *ga.InstanceGroupManager) error

+ func (m *MockInstanceGroupManagers) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroupManager, error)

+ func (m *MockInstanceGroupManagers) Obj(o *ga.InstanceGroupManager) *MockInstanceGroupManagersObj

+ func (m *MockInstanceGroupManagers) Resize(ctx context.Context, key *meta.Key, arg0 int64) error

+ func (m *MockInstanceGroupManagers) SetInstanceTemplate(ctx context.Context, key *meta.Key, ...) error

+ type MockInstanceGroupManagersObj struct

+ Obj interface{}

+ func (m *MockInstanceGroupManagersObj) ToGA() *ga.InstanceGroupManager

+ type MockInstanceTemplates struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockInstanceTemplates) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockInstanceTemplates) (bool, *ga.InstanceTemplate, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.InstanceTemplate, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockInstanceTemplates) (bool, []*ga.InstanceTemplate, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockInstanceTemplatesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockInstanceTemplates(pr ProjectRouter, objs map[meta.Key]*MockInstanceTemplatesObj) *MockInstanceTemplates

+ func (m *MockInstanceTemplates) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockInstanceTemplates) Get(ctx context.Context, key *meta.Key) (*ga.InstanceTemplate, error)

+ func (m *MockInstanceTemplates) Insert(ctx context.Context, key *meta.Key, obj *ga.InstanceTemplate) error

+ func (m *MockInstanceTemplates) List(ctx context.Context, fl *filter.F) ([]*ga.InstanceTemplate, error)

+ func (m *MockInstanceTemplates) Obj(o *ga.InstanceTemplate) *MockInstanceTemplatesObj

+ type MockInstanceTemplatesObj struct

+ Obj interface{}

+ func (m *MockInstanceTemplatesObj) ToGA() *ga.InstanceTemplate

type ResourceID

+ func NewInstanceGroupManagersResourceID(project, zone, name string) *ResourceID

+ func NewInstanceTemplatesResourceID(project, name string) *ResourceID

v1.22.0

Mar 20, 2023

Changes in this version

+ func WithCallObserver(ctx context.Context, obs CallObserver) context.Context

type AlphaBackendServices

+ Patch func(context.Context, *meta.Key, *alpha.BackendService) error

type AlphaRegionBackendServices

+ Patch func(context.Context, *meta.Key, *alpha.BackendService) error

type BetaBackendServices

+ Patch func(context.Context, *meta.Key, *beta.BackendService) error

type BetaRegionBackendServices

+ Patch func(context.Context, *meta.Key, *beta.BackendService) error

+ type CallContextKey struct

+ Operation string

+ ProjectID string

+ Service string

+ Version meta.Version

+ type CallObserver interface

+ End func(ctx context.Context, key *RateLimitKey, err error)

+ Start func(ctx context.Context, key *RateLimitKey)

type GCEAlphaBackendServices

+ func (g *GCEAlphaBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.BackendService) error

type GCEAlphaRegionBackendServices

+ func (g *GCEAlphaRegionBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.BackendService) error

type GCEBetaBackendServices

+ func (g *GCEBetaBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *beta.BackendService) error

type GCEBetaRegionBackendServices

+ func (g *GCEBetaRegionBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *beta.BackendService) error

type GCERegionBackendServices

+ func (g *GCERegionBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *ga.BackendService) error

type MockAlphaBackendServices

+ PatchHook func(context.Context, *meta.Key, *alpha.BackendService, *MockAlphaBackendServices) error

+ func (m *MockAlphaBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.BackendService) error

type MockAlphaRegionBackendServices

+ PatchHook func(context.Context, *meta.Key, *alpha.BackendService, ...) error

+ func (m *MockAlphaRegionBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.BackendService) error

type MockBetaBackendServices

+ PatchHook func(context.Context, *meta.Key, *beta.BackendService, *MockBetaBackendServices) error

+ func (m *MockBetaBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *beta.BackendService) error

type MockBetaRegionBackendServices

+ PatchHook func(context.Context, *meta.Key, *beta.BackendService, ...) error

+ func (m *MockBetaRegionBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *beta.BackendService) error

type MockRegionBackendServices

+ PatchHook func(context.Context, *meta.Key, *ga.BackendService, *MockRegionBackendServices) error

+ func (m *MockRegionBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *ga.BackendService) error

type RegionBackendServices

+ Patch func(context.Context, *meta.Key, *ga.BackendService) error

v1.21.0

Mar 9, 2023

Changes in this version

+ func SetAPIDomain(domain string)

type AcceptRateLimiter

+ func (rl *AcceptRateLimiter) Observe(context.Context, error, *RateLimitKey)

type MinimumRateLimiter

+ func (m *MinimumRateLimiter) Observe(ctx context.Context, err error, key *RateLimitKey)

type NopRateLimiter

+ func (*NopRateLimiter) Observe(context.Context, error, *RateLimitKey)

type RateLimiter

+ Observe func(ctx context.Context, err error, key *RateLimitKey)

v1.20.0

Aug 11, 2022

Changes in this version

type BetaTargetHttpsProxies

+ SetCertificateMap func(context.Context, *meta.Key, *beta.TargetHttpsProxiesSetCertificateMapRequest) error

type GCEBetaTargetHttpsProxies

+ func (g *GCEBetaTargetHttpsProxies) SetCertificateMap(ctx context.Context, key *meta.Key, ...) error

type GCETargetHttpsProxies

+ func (g *GCETargetHttpsProxies) SetCertificateMap(ctx context.Context, key *meta.Key, ...) error

type MockBetaTargetHttpsProxies

+ SetCertificateMapHook func(context.Context, *meta.Key, *beta.TargetHttpsProxiesSetCertificateMapRequest, ...) error

+ func (m *MockBetaTargetHttpsProxies) SetCertificateMap(ctx context.Context, key *meta.Key, ...) error

type MockTargetHttpsProxies

+ SetCertificateMapHook func(context.Context, *meta.Key, *ga.TargetHttpsProxiesSetCertificateMapRequest, ...) error

+ func (m *MockTargetHttpsProxies) SetCertificateMap(ctx context.Context, key *meta.Key, ...) error

type TargetHttpsProxies

+ SetCertificateMap func(context.Context, *meta.Key, *ga.TargetHttpsProxiesSetCertificateMapRequest) error

v1.19.0

Jul 29, 2022

Changes in this version

type AlphaFirewalls

+ Patch func(context.Context, *meta.Key, *alpha.Firewall) error

type AlphaForwardingRules

+ SetLabels func(context.Context, *meta.Key, *alpha.RegionSetLabelsRequest) error

type AlphaGlobalForwardingRules

+ SetLabels func(context.Context, *meta.Key, *alpha.GlobalSetLabelsRequest) error

type BetaFirewalls

+ Patch func(context.Context, *meta.Key, *beta.Firewall) error

type BetaForwardingRules

+ SetLabels func(context.Context, *meta.Key, *beta.RegionSetLabelsRequest) error

type BetaGlobalForwardingRules

+ SetLabels func(context.Context, *meta.Key, *beta.GlobalSetLabelsRequest) error

type Firewalls

+ Patch func(context.Context, *meta.Key, *ga.Firewall) error

type ForwardingRules

+ SetLabels func(context.Context, *meta.Key, *ga.RegionSetLabelsRequest) error

type GCEAlphaFirewalls

+ func (g *GCEAlphaFirewalls) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.Firewall) error

type GCEAlphaForwardingRules

+ func (g *GCEAlphaForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *alpha.RegionSetLabelsRequest) error

type GCEAlphaGlobalForwardingRules

+ func (g *GCEAlphaGlobalForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *alpha.GlobalSetLabelsRequest) error

type GCEBetaFirewalls

+ func (g *GCEBetaFirewalls) Patch(ctx context.Context, key *meta.Key, arg0 *beta.Firewall) error

type GCEBetaForwardingRules

+ func (g *GCEBetaForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *beta.RegionSetLabelsRequest) error

type GCEBetaGlobalForwardingRules

+ func (g *GCEBetaGlobalForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *beta.GlobalSetLabelsRequest) error

type GCEFirewalls

+ func (g *GCEFirewalls) Patch(ctx context.Context, key *meta.Key, arg0 *ga.Firewall) error

type GCEForwardingRules

+ func (g *GCEForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *ga.RegionSetLabelsRequest) error

type GCEGlobalForwardingRules

+ func (g *GCEGlobalForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *ga.GlobalSetLabelsRequest) error

type GlobalForwardingRules

+ SetLabels func(context.Context, *meta.Key, *ga.GlobalSetLabelsRequest) error

type MockAlphaFirewalls

+ PatchHook func(context.Context, *meta.Key, *alpha.Firewall, *MockAlphaFirewalls) error

+ func (m *MockAlphaFirewalls) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.Firewall) error

type MockAlphaForwardingRules

+ SetLabelsHook func(context.Context, *meta.Key, *alpha.RegionSetLabelsRequest, ...) error

+ func (m *MockAlphaForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *alpha.RegionSetLabelsRequest) error

type MockAlphaGlobalForwardingRules

+ SetLabelsHook func(context.Context, *meta.Key, *alpha.GlobalSetLabelsRequest, ...) error

+ func (m *MockAlphaGlobalForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *alpha.GlobalSetLabelsRequest) error

type MockBetaFirewalls

+ PatchHook func(context.Context, *meta.Key, *beta.Firewall, *MockBetaFirewalls) error

+ func (m *MockBetaFirewalls) Patch(ctx context.Context, key *meta.Key, arg0 *beta.Firewall) error

type MockBetaForwardingRules

+ SetLabelsHook func(context.Context, *meta.Key, *beta.RegionSetLabelsRequest, ...) error

+ func (m *MockBetaForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *beta.RegionSetLabelsRequest) error

type MockBetaGlobalForwardingRules

+ SetLabelsHook func(context.Context, *meta.Key, *beta.GlobalSetLabelsRequest, ...) error

+ func (m *MockBetaGlobalForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *beta.GlobalSetLabelsRequest) error

type MockFirewalls

+ PatchHook func(context.Context, *meta.Key, *ga.Firewall, *MockFirewalls) error

+ func (m *MockFirewalls) Patch(ctx context.Context, key *meta.Key, arg0 *ga.Firewall) error

type MockForwardingRules

+ SetLabelsHook func(context.Context, *meta.Key, *ga.RegionSetLabelsRequest, *MockForwardingRules) error

+ func (m *MockForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *ga.RegionSetLabelsRequest) error

type MockGlobalForwardingRules

+ SetLabelsHook func(context.Context, *meta.Key, *ga.GlobalSetLabelsRequest, ...) error

+ func (m *MockGlobalForwardingRules) SetLabels(ctx context.Context, key *meta.Key, arg0 *ga.GlobalSetLabelsRequest) error

v1.18.0

Nov 10, 2021

Changes in this version

type AlphaBackendServices

+ AddSignedUrlKey func(context.Context, *meta.Key, *alpha.SignedUrlKey) error

+ DeleteSignedUrlKey func(context.Context, *meta.Key, string) error

type BackendServices

+ AddSignedUrlKey func(context.Context, *meta.Key, *ga.SignedUrlKey) error

+ DeleteSignedUrlKey func(context.Context, *meta.Key, string) error

type BetaBackendServices

+ AddSignedUrlKey func(context.Context, *meta.Key, *beta.SignedUrlKey) error

+ DeleteSignedUrlKey func(context.Context, *meta.Key, string) error

type Cloud

+ ServiceAttachments func() ServiceAttachments

type GCE

+ func (gce *GCE) ServiceAttachments() ServiceAttachments

type GCEAlphaBackendServices

+ func (g *GCEAlphaBackendServices) AddSignedUrlKey(ctx context.Context, key *meta.Key, arg0 *alpha.SignedUrlKey) error

+ func (g *GCEAlphaBackendServices) DeleteSignedUrlKey(ctx context.Context, key *meta.Key, arg0 string) error

type GCEBackendServices

+ func (g *GCEBackendServices) AddSignedUrlKey(ctx context.Context, key *meta.Key, arg0 *ga.SignedUrlKey) error

+ func (g *GCEBackendServices) DeleteSignedUrlKey(ctx context.Context, key *meta.Key, arg0 string) error

type GCEBetaBackendServices

+ func (g *GCEBetaBackendServices) AddSignedUrlKey(ctx context.Context, key *meta.Key, arg0 *beta.SignedUrlKey) error

+ func (g *GCEBetaBackendServices) DeleteSignedUrlKey(ctx context.Context, key *meta.Key, arg0 string) error

+ type GCEServiceAttachments struct

+ func (g *GCEServiceAttachments) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEServiceAttachments) Get(ctx context.Context, key *meta.Key) (*ga.ServiceAttachment, error)

+ func (g *GCEServiceAttachments) Insert(ctx context.Context, key *meta.Key, obj *ga.ServiceAttachment) error

+ func (g *GCEServiceAttachments) List(ctx context.Context, region string, fl *filter.F) ([]*ga.ServiceAttachment, error)

+ func (g *GCEServiceAttachments) Patch(ctx context.Context, key *meta.Key, arg0 *ga.ServiceAttachment) error

type MockAlphaBackendServices

+ AddSignedUrlKeyHook func(context.Context, *meta.Key, *alpha.SignedUrlKey, *MockAlphaBackendServices) error

+ DeleteSignedUrlKeyHook func(context.Context, *meta.Key, string, *MockAlphaBackendServices) error

+ func (m *MockAlphaBackendServices) AddSignedUrlKey(ctx context.Context, key *meta.Key, arg0 *alpha.SignedUrlKey) error

+ func (m *MockAlphaBackendServices) DeleteSignedUrlKey(ctx context.Context, key *meta.Key, arg0 string) error

type MockBackendServices

+ AddSignedUrlKeyHook func(context.Context, *meta.Key, *ga.SignedUrlKey, *MockBackendServices) error

+ DeleteSignedUrlKeyHook func(context.Context, *meta.Key, string, *MockBackendServices) error

+ func (m *MockBackendServices) AddSignedUrlKey(ctx context.Context, key *meta.Key, arg0 *ga.SignedUrlKey) error

+ func (m *MockBackendServices) DeleteSignedUrlKey(ctx context.Context, key *meta.Key, arg0 string) error

type MockBetaBackendServices

+ AddSignedUrlKeyHook func(context.Context, *meta.Key, *beta.SignedUrlKey, *MockBetaBackendServices) error

+ DeleteSignedUrlKeyHook func(context.Context, *meta.Key, string, *MockBetaBackendServices) error

+ func (m *MockBetaBackendServices) AddSignedUrlKey(ctx context.Context, key *meta.Key, arg0 *beta.SignedUrlKey) error

+ func (m *MockBetaBackendServices) DeleteSignedUrlKey(ctx context.Context, key *meta.Key, arg0 string) error

type MockGCE

+ MockServiceAttachments *MockServiceAttachments

+ func (mock *MockGCE) ServiceAttachments() ServiceAttachments

+ type MockServiceAttachments struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockServiceAttachments) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockServiceAttachments) (bool, *ga.ServiceAttachment, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.ServiceAttachment, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockServiceAttachments) (bool, []*ga.ServiceAttachment, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockServiceAttachmentsObj

+ PatchHook func(context.Context, *meta.Key, *ga.ServiceAttachment, *MockServiceAttachments) error

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockServiceAttachments(pr ProjectRouter, objs map[meta.Key]*MockServiceAttachmentsObj) *MockServiceAttachments

+ func (m *MockServiceAttachments) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockServiceAttachments) Get(ctx context.Context, key *meta.Key) (*ga.ServiceAttachment, error)

+ func (m *MockServiceAttachments) Insert(ctx context.Context, key *meta.Key, obj *ga.ServiceAttachment) error

+ func (m *MockServiceAttachments) List(ctx context.Context, region string, fl *filter.F) ([]*ga.ServiceAttachment, error)

+ func (m *MockServiceAttachments) Obj(o *ga.ServiceAttachment) *MockServiceAttachmentsObj

+ func (m *MockServiceAttachments) Patch(ctx context.Context, key *meta.Key, arg0 *ga.ServiceAttachment) error

type MockServiceAttachmentsObj

+ func (m *MockServiceAttachmentsObj) ToGA() *ga.ServiceAttachment

+ type ServiceAttachments interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.ServiceAttachment, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.ServiceAttachment) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.ServiceAttachment, error)

+ Patch func(context.Context, *meta.Key, *ga.ServiceAttachment) error

v1.17.0

Jul 21, 2021

Changes in this version

+ type AlphaImages interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.Image, error)

+ GetFromFamily func(context.Context, *meta.Key) (*alpha.Image, error)

+ GetIamPolicy func(context.Context, *meta.Key) (*alpha.Policy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.Image) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.Image, error)

+ Patch func(context.Context, *meta.Key, *alpha.Image) error

+ SetIamPolicy func(context.Context, *meta.Key, *alpha.GlobalSetPolicyRequest) (*alpha.Policy, error)

+ SetLabels func(context.Context, *meta.Key, *alpha.GlobalSetLabelsRequest) error

+ TestIamPermissions func(context.Context, *meta.Key, *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

+ type AlphaNetworkFirewallPolicies interface

+ AddAssociation func(context.Context, *meta.Key, *alpha.FirewallPolicyAssociation) error

+ AddRule func(context.Context, *meta.Key, *alpha.FirewallPolicyRule) error

+ CloneRules func(context.Context, *meta.Key) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicy, error)

+ GetAssociation func(context.Context, *meta.Key) (*alpha.FirewallPolicyAssociation, error)

+ GetIamPolicy func(context.Context, *meta.Key) (*alpha.Policy, error)

+ GetRule func(context.Context, *meta.Key) (*alpha.FirewallPolicyRule, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.FirewallPolicy) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.FirewallPolicy, error)

+ Patch func(context.Context, *meta.Key, *alpha.FirewallPolicy) error

+ PatchRule func(context.Context, *meta.Key, *alpha.FirewallPolicyRule) error

+ RemoveAssociation func(context.Context, *meta.Key) error

+ RemoveRule func(context.Context, *meta.Key) error

+ SetIamPolicy func(context.Context, *meta.Key, *alpha.GlobalSetPolicyRequest) (*alpha.Policy, error)

+ TestIamPermissions func(context.Context, *meta.Key, *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

+ type AlphaRegionNetworkFirewallPolicies interface

+ AddAssociation func(context.Context, *meta.Key, *alpha.FirewallPolicyAssociation) error

+ AddRule func(context.Context, *meta.Key, *alpha.FirewallPolicyRule) error

+ CloneRules func(context.Context, *meta.Key) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicy, error)

+ GetAssociation func(context.Context, *meta.Key) (*alpha.FirewallPolicyAssociation, error)

+ GetIamPolicy func(context.Context, *meta.Key) (*alpha.Policy, error)

+ GetRule func(context.Context, *meta.Key) (*alpha.FirewallPolicyRule, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.FirewallPolicy) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.FirewallPolicy, error)

+ Patch func(context.Context, *meta.Key, *alpha.FirewallPolicy) error

+ PatchRule func(context.Context, *meta.Key, *alpha.FirewallPolicyRule) error

+ RemoveAssociation func(context.Context, *meta.Key) error

+ RemoveRule func(context.Context, *meta.Key) error

+ SetIamPolicy func(context.Context, *meta.Key, *alpha.RegionSetPolicyRequest) (*alpha.Policy, error)

+ TestIamPermissions func(context.Context, *meta.Key, *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

+ type AlphaRouters interface

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*alpha.Router, error)

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.Router, error)

+ GetRouterStatus func(context.Context, *meta.Key) (*alpha.RouterStatusResponse, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.Router) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.Router, error)

+ Patch func(context.Context, *meta.Key, *alpha.Router) error

+ Preview func(context.Context, *meta.Key, *alpha.Router) (*alpha.RoutersPreviewResponse, error)

+ TestIamPermissions func(context.Context, *meta.Key, *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

type AlphaSubnetworks

+ Patch func(context.Context, *meta.Key, *alpha.Subnetwork) error

type AlphaTargetHttpsProxies

+ SetCertificateMap func(context.Context, *meta.Key, *alpha.TargetHttpsProxiesSetCertificateMapRequest) error

+ type BetaImages interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.Image, error)

+ GetFromFamily func(context.Context, *meta.Key) (*beta.Image, error)

+ GetIamPolicy func(context.Context, *meta.Key) (*beta.Policy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.Image) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.Image, error)

+ Patch func(context.Context, *meta.Key, *beta.Image) error

+ SetIamPolicy func(context.Context, *meta.Key, *beta.GlobalSetPolicyRequest) (*beta.Policy, error)

+ SetLabels func(context.Context, *meta.Key, *beta.GlobalSetLabelsRequest) error

+ TestIamPermissions func(context.Context, *meta.Key, *beta.TestPermissionsRequest) (*beta.TestPermissionsResponse, error)

+ type BetaRouters interface

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*beta.Router, error)

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.Router, error)

+ GetRouterStatus func(context.Context, *meta.Key) (*beta.RouterStatusResponse, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.Router) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.Router, error)

+ Patch func(context.Context, *meta.Key, *beta.Router) error

+ Preview func(context.Context, *meta.Key, *beta.Router) (*beta.RoutersPreviewResponse, error)

+ TestIamPermissions func(context.Context, *meta.Key, *beta.TestPermissionsRequest) (*beta.TestPermissionsResponse, error)

type BetaSubnetworks

+ Patch func(context.Context, *meta.Key, *beta.Subnetwork) error

type Cloud

+ AlphaImages func() AlphaImages

+ AlphaNetworkFirewallPolicies func() AlphaNetworkFirewallPolicies

+ AlphaRegionNetworkFirewallPolicies func() AlphaRegionNetworkFirewallPolicies

+ AlphaRouters func() AlphaRouters

+ BetaImages func() BetaImages

+ BetaRouters func() BetaRouters

+ Images func() Images

+ Routers func() Routers

+ TargetTcpProxies func() TargetTcpProxies

type GCE

+ func (gce *GCE) AlphaImages() AlphaImages

+ func (gce *GCE) AlphaNetworkFirewallPolicies() AlphaNetworkFirewallPolicies

+ func (gce *GCE) AlphaRegionNetworkFirewallPolicies() AlphaRegionNetworkFirewallPolicies

+ func (gce *GCE) AlphaRouters() AlphaRouters

+ func (gce *GCE) BetaImages() BetaImages

+ func (gce *GCE) BetaRouters() BetaRouters

+ func (gce *GCE) Images() Images

+ func (gce *GCE) Routers() Routers

+ func (gce *GCE) TargetTcpProxies() TargetTcpProxies

+ type GCEAlphaImages struct

+ func (g *GCEAlphaImages) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaImages) Get(ctx context.Context, key *meta.Key) (*alpha.Image, error)

+ func (g *GCEAlphaImages) GetFromFamily(ctx context.Context, key *meta.Key) (*alpha.Image, error)

+ func (g *GCEAlphaImages) GetIamPolicy(ctx context.Context, key *meta.Key) (*alpha.Policy, error)

+ func (g *GCEAlphaImages) Insert(ctx context.Context, key *meta.Key, obj *alpha.Image) error

+ func (g *GCEAlphaImages) List(ctx context.Context, fl *filter.F) ([]*alpha.Image, error)

+ func (g *GCEAlphaImages) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.Image) error

+ func (g *GCEAlphaImages) SetIamPolicy(ctx context.Context, key *meta.Key, arg0 *alpha.GlobalSetPolicyRequest) (*alpha.Policy, error)

+ func (g *GCEAlphaImages) SetLabels(ctx context.Context, key *meta.Key, arg0 *alpha.GlobalSetLabelsRequest) error

+ func (g *GCEAlphaImages) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

+ type GCEAlphaNetworkFirewallPolicies struct

+ func (g *GCEAlphaNetworkFirewallPolicies) AddAssociation(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyAssociation) error

+ func (g *GCEAlphaNetworkFirewallPolicies) AddRule(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyRule) error

+ func (g *GCEAlphaNetworkFirewallPolicies) CloneRules(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaNetworkFirewallPolicies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaNetworkFirewallPolicies) Get(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicy, error)

+ func (g *GCEAlphaNetworkFirewallPolicies) GetAssociation(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicyAssociation, error)

+ func (g *GCEAlphaNetworkFirewallPolicies) GetIamPolicy(ctx context.Context, key *meta.Key) (*alpha.Policy, error)

+ func (g *GCEAlphaNetworkFirewallPolicies) GetRule(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicyRule, error)

+ func (g *GCEAlphaNetworkFirewallPolicies) Insert(ctx context.Context, key *meta.Key, obj *alpha.FirewallPolicy) error

+ func (g *GCEAlphaNetworkFirewallPolicies) List(ctx context.Context, fl *filter.F) ([]*alpha.FirewallPolicy, error)

+ func (g *GCEAlphaNetworkFirewallPolicies) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicy) error

+ func (g *GCEAlphaNetworkFirewallPolicies) PatchRule(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyRule) error

+ func (g *GCEAlphaNetworkFirewallPolicies) RemoveAssociation(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaNetworkFirewallPolicies) RemoveRule(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaNetworkFirewallPolicies) SetIamPolicy(ctx context.Context, key *meta.Key, arg0 *alpha.GlobalSetPolicyRequest) (*alpha.Policy, error)

+ func (g *GCEAlphaNetworkFirewallPolicies) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

+ type GCEAlphaRegionNetworkFirewallPolicies struct

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) AddAssociation(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyAssociation) error

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) AddRule(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyRule) error

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) CloneRules(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) Get(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicy, error)

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) GetAssociation(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicyAssociation, error)

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) GetIamPolicy(ctx context.Context, key *meta.Key) (*alpha.Policy, error)

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) GetRule(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicyRule, error)

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) Insert(ctx context.Context, key *meta.Key, obj *alpha.FirewallPolicy) error

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.FirewallPolicy, error)

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicy) error

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) PatchRule(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyRule) error

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) RemoveAssociation(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) RemoveRule(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) SetIamPolicy(ctx context.Context, key *meta.Key, arg0 *alpha.RegionSetPolicyRequest) (*alpha.Policy, error)

+ func (g *GCEAlphaRegionNetworkFirewallPolicies) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

+ type GCEAlphaRouters struct

+ func (g *GCEAlphaRouters) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.Router, error)

+ func (g *GCEAlphaRouters) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRouters) Get(ctx context.Context, key *meta.Key) (*alpha.Router, error)

+ func (g *GCEAlphaRouters) GetRouterStatus(ctx context.Context, key *meta.Key) (*alpha.RouterStatusResponse, error)

+ func (g *GCEAlphaRouters) Insert(ctx context.Context, key *meta.Key, obj *alpha.Router) error

+ func (g *GCEAlphaRouters) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Router, error)

+ func (g *GCEAlphaRouters) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.Router) error

+ func (g *GCEAlphaRouters) Preview(ctx context.Context, key *meta.Key, arg0 *alpha.Router) (*alpha.RoutersPreviewResponse, error)

+ func (g *GCEAlphaRouters) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

type GCEAlphaSubnetworks

+ func (g *GCEAlphaSubnetworks) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.Subnetwork) error

type GCEAlphaTargetHttpsProxies

+ func (g *GCEAlphaTargetHttpsProxies) SetCertificateMap(ctx context.Context, key *meta.Key, ...) error

+ type GCEBetaImages struct

+ func (g *GCEBetaImages) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaImages) Get(ctx context.Context, key *meta.Key) (*beta.Image, error)

+ func (g *GCEBetaImages) GetFromFamily(ctx context.Context, key *meta.Key) (*beta.Image, error)

+ func (g *GCEBetaImages) GetIamPolicy(ctx context.Context, key *meta.Key) (*beta.Policy, error)

+ func (g *GCEBetaImages) Insert(ctx context.Context, key *meta.Key, obj *beta.Image) error

+ func (g *GCEBetaImages) List(ctx context.Context, fl *filter.F) ([]*beta.Image, error)

+ func (g *GCEBetaImages) Patch(ctx context.Context, key *meta.Key, arg0 *beta.Image) error

+ func (g *GCEBetaImages) SetIamPolicy(ctx context.Context, key *meta.Key, arg0 *beta.GlobalSetPolicyRequest) (*beta.Policy, error)

+ func (g *GCEBetaImages) SetLabels(ctx context.Context, key *meta.Key, arg0 *beta.GlobalSetLabelsRequest) error

+ func (g *GCEBetaImages) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *beta.TestPermissionsRequest) (*beta.TestPermissionsResponse, error)

+ type GCEBetaRouters struct

+ func (g *GCEBetaRouters) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*beta.Router, error)

+ func (g *GCEBetaRouters) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaRouters) Get(ctx context.Context, key *meta.Key) (*beta.Router, error)

+ func (g *GCEBetaRouters) GetRouterStatus(ctx context.Context, key *meta.Key) (*beta.RouterStatusResponse, error)

+ func (g *GCEBetaRouters) Insert(ctx context.Context, key *meta.Key, obj *beta.Router) error

+ func (g *GCEBetaRouters) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Router, error)

+ func (g *GCEBetaRouters) Patch(ctx context.Context, key *meta.Key, arg0 *beta.Router) error

+ func (g *GCEBetaRouters) Preview(ctx context.Context, key *meta.Key, arg0 *beta.Router) (*beta.RoutersPreviewResponse, error)

+ func (g *GCEBetaRouters) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *beta.TestPermissionsRequest) (*beta.TestPermissionsResponse, error)

type GCEBetaSubnetworks

+ func (g *GCEBetaSubnetworks) Patch(ctx context.Context, key *meta.Key, arg0 *beta.Subnetwork) error

+ type GCEImages struct

+ func (g *GCEImages) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEImages) Get(ctx context.Context, key *meta.Key) (*ga.Image, error)

+ func (g *GCEImages) GetFromFamily(ctx context.Context, key *meta.Key) (*ga.Image, error)

+ func (g *GCEImages) GetIamPolicy(ctx context.Context, key *meta.Key) (*ga.Policy, error)

+ func (g *GCEImages) Insert(ctx context.Context, key *meta.Key, obj *ga.Image) error

+ func (g *GCEImages) List(ctx context.Context, fl *filter.F) ([]*ga.Image, error)

+ func (g *GCEImages) Patch(ctx context.Context, key *meta.Key, arg0 *ga.Image) error

+ func (g *GCEImages) SetIamPolicy(ctx context.Context, key *meta.Key, arg0 *ga.GlobalSetPolicyRequest) (*ga.Policy, error)

+ func (g *GCEImages) SetLabels(ctx context.Context, key *meta.Key, arg0 *ga.GlobalSetLabelsRequest) error

+ func (g *GCEImages) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *ga.TestPermissionsRequest) (*ga.TestPermissionsResponse, error)

+ type GCERouters struct

+ func (g *GCERouters) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*ga.Router, error)

+ func (g *GCERouters) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCERouters) Get(ctx context.Context, key *meta.Key) (*ga.Router, error)

+ func (g *GCERouters) GetRouterStatus(ctx context.Context, key *meta.Key) (*ga.RouterStatusResponse, error)

+ func (g *GCERouters) Insert(ctx context.Context, key *meta.Key, obj *ga.Router) error

+ func (g *GCERouters) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Router, error)

+ func (g *GCERouters) Patch(ctx context.Context, key *meta.Key, arg0 *ga.Router) error

+ func (g *GCERouters) Preview(ctx context.Context, key *meta.Key, arg0 *ga.Router) (*ga.RoutersPreviewResponse, error)

type GCESubnetworks

+ func (g *GCESubnetworks) Patch(ctx context.Context, key *meta.Key, arg0 *ga.Subnetwork) error

+ type GCETargetTcpProxies struct

+ func (g *GCETargetTcpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCETargetTcpProxies) Get(ctx context.Context, key *meta.Key) (*ga.TargetTcpProxy, error)

+ func (g *GCETargetTcpProxies) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetTcpProxy) error

+ func (g *GCETargetTcpProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetTcpProxy, error)

+ func (g *GCETargetTcpProxies) SetBackendService(ctx context.Context, key *meta.Key, ...) error

+ type Images interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Image, error)

+ GetFromFamily func(context.Context, *meta.Key) (*ga.Image, error)

+ GetIamPolicy func(context.Context, *meta.Key) (*ga.Policy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Image) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.Image, error)

+ Patch func(context.Context, *meta.Key, *ga.Image) error

+ SetIamPolicy func(context.Context, *meta.Key, *ga.GlobalSetPolicyRequest) (*ga.Policy, error)

+ SetLabels func(context.Context, *meta.Key, *ga.GlobalSetLabelsRequest) error

+ TestIamPermissions func(context.Context, *meta.Key, *ga.TestPermissionsRequest) (*ga.TestPermissionsResponse, error)

+ type MockAlphaImages struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaImages) (bool, error)

+ GetError map[meta.Key]error

+ GetFromFamilyHook func(context.Context, *meta.Key, *MockAlphaImages) (*alpha.Image, error)

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaImages) (bool, *alpha.Image, error)

+ GetIamPolicyHook func(context.Context, *meta.Key, *MockAlphaImages) (*alpha.Policy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.Image, m *MockAlphaImages) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaImages) (bool, []*alpha.Image, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockImagesObj

+ PatchHook func(context.Context, *meta.Key, *alpha.Image, *MockAlphaImages) error

+ ProjectRouter ProjectRouter

+ SetIamPolicyHook func(context.Context, *meta.Key, *alpha.GlobalSetPolicyRequest, *MockAlphaImages) (*alpha.Policy, error)

+ SetLabelsHook func(context.Context, *meta.Key, *alpha.GlobalSetLabelsRequest, *MockAlphaImages) error

+ TestIamPermissionsHook func(context.Context, *meta.Key, *alpha.TestPermissionsRequest, *MockAlphaImages) (*alpha.TestPermissionsResponse, error)

+ X interface{}

+ func NewMockAlphaImages(pr ProjectRouter, objs map[meta.Key]*MockImagesObj) *MockAlphaImages

+ func (m *MockAlphaImages) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaImages) Get(ctx context.Context, key *meta.Key) (*alpha.Image, error)

+ func (m *MockAlphaImages) GetFromFamily(ctx context.Context, key *meta.Key) (*alpha.Image, error)

+ func (m *MockAlphaImages) GetIamPolicy(ctx context.Context, key *meta.Key) (*alpha.Policy, error)

+ func (m *MockAlphaImages) Insert(ctx context.Context, key *meta.Key, obj *alpha.Image) error

+ func (m *MockAlphaImages) List(ctx context.Context, fl *filter.F) ([]*alpha.Image, error)

+ func (m *MockAlphaImages) Obj(o *alpha.Image) *MockImagesObj

+ func (m *MockAlphaImages) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.Image) error

+ func (m *MockAlphaImages) SetIamPolicy(ctx context.Context, key *meta.Key, arg0 *alpha.GlobalSetPolicyRequest) (*alpha.Policy, error)

+ func (m *MockAlphaImages) SetLabels(ctx context.Context, key *meta.Key, arg0 *alpha.GlobalSetLabelsRequest) error

+ func (m *MockAlphaImages) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

+ type MockAlphaNetworkFirewallPolicies struct

+ AddAssociationHook func(context.Context, *meta.Key, *alpha.FirewallPolicyAssociation, ...) error

+ AddRuleHook func(context.Context, *meta.Key, *alpha.FirewallPolicyRule, ...) error

+ CloneRulesHook func(context.Context, *meta.Key, *MockAlphaNetworkFirewallPolicies) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaNetworkFirewallPolicies) (bool, error)

+ GetAssociationHook func(context.Context, *meta.Key, *MockAlphaNetworkFirewallPolicies) (*alpha.FirewallPolicyAssociation, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaNetworkFirewallPolicies) (bool, *alpha.FirewallPolicy, error)

+ GetIamPolicyHook func(context.Context, *meta.Key, *MockAlphaNetworkFirewallPolicies) (*alpha.Policy, error)

+ GetRuleHook func(context.Context, *meta.Key, *MockAlphaNetworkFirewallPolicies) (*alpha.FirewallPolicyRule, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.FirewallPolicy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaNetworkFirewallPolicies) (bool, []*alpha.FirewallPolicy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockNetworkFirewallPoliciesObj

+ PatchHook func(context.Context, *meta.Key, *alpha.FirewallPolicy, ...) error

+ PatchRuleHook func(context.Context, *meta.Key, *alpha.FirewallPolicyRule, ...) error

+ ProjectRouter ProjectRouter

+ RemoveAssociationHook func(context.Context, *meta.Key, *MockAlphaNetworkFirewallPolicies) error

+ RemoveRuleHook func(context.Context, *meta.Key, *MockAlphaNetworkFirewallPolicies) error

+ SetIamPolicyHook func(context.Context, *meta.Key, *alpha.GlobalSetPolicyRequest, ...) (*alpha.Policy, error)

+ TestIamPermissionsHook func(context.Context, *meta.Key, *alpha.TestPermissionsRequest, ...) (*alpha.TestPermissionsResponse, error)

+ X interface{}

+ func NewMockAlphaNetworkFirewallPolicies(pr ProjectRouter, objs map[meta.Key]*MockNetworkFirewallPoliciesObj) *MockAlphaNetworkFirewallPolicies

+ func (m *MockAlphaNetworkFirewallPolicies) AddAssociation(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyAssociation) error

+ func (m *MockAlphaNetworkFirewallPolicies) AddRule(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyRule) error

+ func (m *MockAlphaNetworkFirewallPolicies) CloneRules(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaNetworkFirewallPolicies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaNetworkFirewallPolicies) Get(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicy, error)

+ func (m *MockAlphaNetworkFirewallPolicies) GetAssociation(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicyAssociation, error)

+ func (m *MockAlphaNetworkFirewallPolicies) GetIamPolicy(ctx context.Context, key *meta.Key) (*alpha.Policy, error)

+ func (m *MockAlphaNetworkFirewallPolicies) GetRule(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicyRule, error)

+ func (m *MockAlphaNetworkFirewallPolicies) Insert(ctx context.Context, key *meta.Key, obj *alpha.FirewallPolicy) error

+ func (m *MockAlphaNetworkFirewallPolicies) List(ctx context.Context, fl *filter.F) ([]*alpha.FirewallPolicy, error)

+ func (m *MockAlphaNetworkFirewallPolicies) Obj(o *alpha.FirewallPolicy) *MockNetworkFirewallPoliciesObj

+ func (m *MockAlphaNetworkFirewallPolicies) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicy) error

+ func (m *MockAlphaNetworkFirewallPolicies) PatchRule(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyRule) error

+ func (m *MockAlphaNetworkFirewallPolicies) RemoveAssociation(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaNetworkFirewallPolicies) RemoveRule(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaNetworkFirewallPolicies) SetIamPolicy(ctx context.Context, key *meta.Key, arg0 *alpha.GlobalSetPolicyRequest) (*alpha.Policy, error)

+ func (m *MockAlphaNetworkFirewallPolicies) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

+ type MockAlphaRegionNetworkFirewallPolicies struct

+ AddAssociationHook func(context.Context, *meta.Key, *alpha.FirewallPolicyAssociation, ...) error

+ AddRuleHook func(context.Context, *meta.Key, *alpha.FirewallPolicyRule, ...) error

+ CloneRulesHook func(context.Context, *meta.Key, *MockAlphaRegionNetworkFirewallPolicies) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionNetworkFirewallPolicies) (bool, error)

+ GetAssociationHook func(context.Context, *meta.Key, *MockAlphaRegionNetworkFirewallPolicies) (*alpha.FirewallPolicyAssociation, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionNetworkFirewallPolicies) (bool, *alpha.FirewallPolicy, error)

+ GetIamPolicyHook func(context.Context, *meta.Key, *MockAlphaRegionNetworkFirewallPolicies) (*alpha.Policy, error)

+ GetRuleHook func(context.Context, *meta.Key, *MockAlphaRegionNetworkFirewallPolicies) (*alpha.FirewallPolicyRule, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.FirewallPolicy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*alpha.FirewallPolicy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionNetworkFirewallPoliciesObj

+ PatchHook func(context.Context, *meta.Key, *alpha.FirewallPolicy, ...) error

+ PatchRuleHook func(context.Context, *meta.Key, *alpha.FirewallPolicyRule, ...) error

+ ProjectRouter ProjectRouter

+ RemoveAssociationHook func(context.Context, *meta.Key, *MockAlphaRegionNetworkFirewallPolicies) error

+ RemoveRuleHook func(context.Context, *meta.Key, *MockAlphaRegionNetworkFirewallPolicies) error

+ SetIamPolicyHook func(context.Context, *meta.Key, *alpha.RegionSetPolicyRequest, ...) (*alpha.Policy, error)

+ TestIamPermissionsHook func(context.Context, *meta.Key, *alpha.TestPermissionsRequest, ...) (*alpha.TestPermissionsResponse, error)

+ X interface{}

+ func NewMockAlphaRegionNetworkFirewallPolicies(pr ProjectRouter, objs map[meta.Key]*MockRegionNetworkFirewallPoliciesObj) *MockAlphaRegionNetworkFirewallPolicies

+ func (m *MockAlphaRegionNetworkFirewallPolicies) AddAssociation(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyAssociation) error

+ func (m *MockAlphaRegionNetworkFirewallPolicies) AddRule(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyRule) error

+ func (m *MockAlphaRegionNetworkFirewallPolicies) CloneRules(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRegionNetworkFirewallPolicies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRegionNetworkFirewallPolicies) Get(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicy, error)

+ func (m *MockAlphaRegionNetworkFirewallPolicies) GetAssociation(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicyAssociation, error)

+ func (m *MockAlphaRegionNetworkFirewallPolicies) GetIamPolicy(ctx context.Context, key *meta.Key) (*alpha.Policy, error)

+ func (m *MockAlphaRegionNetworkFirewallPolicies) GetRule(ctx context.Context, key *meta.Key) (*alpha.FirewallPolicyRule, error)

+ func (m *MockAlphaRegionNetworkFirewallPolicies) Insert(ctx context.Context, key *meta.Key, obj *alpha.FirewallPolicy) error

+ func (m *MockAlphaRegionNetworkFirewallPolicies) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.FirewallPolicy, error)

+ func (m *MockAlphaRegionNetworkFirewallPolicies) Obj(o *alpha.FirewallPolicy) *MockRegionNetworkFirewallPoliciesObj

+ func (m *MockAlphaRegionNetworkFirewallPolicies) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicy) error

+ func (m *MockAlphaRegionNetworkFirewallPolicies) PatchRule(ctx context.Context, key *meta.Key, arg0 *alpha.FirewallPolicyRule) error

+ func (m *MockAlphaRegionNetworkFirewallPolicies) RemoveAssociation(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRegionNetworkFirewallPolicies) RemoveRule(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRegionNetworkFirewallPolicies) SetIamPolicy(ctx context.Context, key *meta.Key, arg0 *alpha.RegionSetPolicyRequest) (*alpha.Policy, error)

+ func (m *MockAlphaRegionNetworkFirewallPolicies) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

+ type MockAlphaRouters struct

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockAlphaRouters) (bool, map[string][]*alpha.Router, error)

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRouters) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRouters) (bool, *alpha.Router, error)

+ GetRouterStatusHook func(context.Context, *meta.Key, *MockAlphaRouters) (*alpha.RouterStatusResponse, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.Router, m *MockAlphaRouters) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaRouters) (bool, []*alpha.Router, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRoutersObj

+ PatchHook func(context.Context, *meta.Key, *alpha.Router, *MockAlphaRouters) error

+ PreviewHook func(context.Context, *meta.Key, *alpha.Router, *MockAlphaRouters) (*alpha.RoutersPreviewResponse, error)

+ ProjectRouter ProjectRouter

+ TestIamPermissionsHook func(context.Context, *meta.Key, *alpha.TestPermissionsRequest, *MockAlphaRouters) (*alpha.TestPermissionsResponse, error)

+ X interface{}

+ func NewMockAlphaRouters(pr ProjectRouter, objs map[meta.Key]*MockRoutersObj) *MockAlphaRouters

+ func (m *MockAlphaRouters) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.Router, error)

+ func (m *MockAlphaRouters) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRouters) Get(ctx context.Context, key *meta.Key) (*alpha.Router, error)

+ func (m *MockAlphaRouters) GetRouterStatus(ctx context.Context, key *meta.Key) (*alpha.RouterStatusResponse, error)

+ func (m *MockAlphaRouters) Insert(ctx context.Context, key *meta.Key, obj *alpha.Router) error

+ func (m *MockAlphaRouters) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Router, error)

+ func (m *MockAlphaRouters) Obj(o *alpha.Router) *MockRoutersObj

+ func (m *MockAlphaRouters) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.Router) error

+ func (m *MockAlphaRouters) Preview(ctx context.Context, key *meta.Key, arg0 *alpha.Router) (*alpha.RoutersPreviewResponse, error)

+ func (m *MockAlphaRouters) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *alpha.TestPermissionsRequest) (*alpha.TestPermissionsResponse, error)

type MockAlphaSubnetworks

+ PatchHook func(context.Context, *meta.Key, *alpha.Subnetwork, *MockAlphaSubnetworks) error

+ func (m *MockAlphaSubnetworks) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.Subnetwork) error

type MockAlphaTargetHttpsProxies

+ SetCertificateMapHook func(context.Context, *meta.Key, *alpha.TargetHttpsProxiesSetCertificateMapRequest, ...) error

+ func (m *MockAlphaTargetHttpsProxies) SetCertificateMap(ctx context.Context, key *meta.Key, ...) error

+ type MockBetaImages struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaImages) (bool, error)

+ GetError map[meta.Key]error

+ GetFromFamilyHook func(context.Context, *meta.Key, *MockBetaImages) (*beta.Image, error)

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaImages) (bool, *beta.Image, error)

+ GetIamPolicyHook func(context.Context, *meta.Key, *MockBetaImages) (*beta.Policy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.Image, m *MockBetaImages) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaImages) (bool, []*beta.Image, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockImagesObj

+ PatchHook func(context.Context, *meta.Key, *beta.Image, *MockBetaImages) error

+ ProjectRouter ProjectRouter

+ SetIamPolicyHook func(context.Context, *meta.Key, *beta.GlobalSetPolicyRequest, *MockBetaImages) (*beta.Policy, error)

+ SetLabelsHook func(context.Context, *meta.Key, *beta.GlobalSetLabelsRequest, *MockBetaImages) error

+ TestIamPermissionsHook func(context.Context, *meta.Key, *beta.TestPermissionsRequest, *MockBetaImages) (*beta.TestPermissionsResponse, error)

+ X interface{}

+ func NewMockBetaImages(pr ProjectRouter, objs map[meta.Key]*MockImagesObj) *MockBetaImages

+ func (m *MockBetaImages) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaImages) Get(ctx context.Context, key *meta.Key) (*beta.Image, error)

+ func (m *MockBetaImages) GetFromFamily(ctx context.Context, key *meta.Key) (*beta.Image, error)

+ func (m *MockBetaImages) GetIamPolicy(ctx context.Context, key *meta.Key) (*beta.Policy, error)

+ func (m *MockBetaImages) Insert(ctx context.Context, key *meta.Key, obj *beta.Image) error

+ func (m *MockBetaImages) List(ctx context.Context, fl *filter.F) ([]*beta.Image, error)

+ func (m *MockBetaImages) Obj(o *beta.Image) *MockImagesObj

+ func (m *MockBetaImages) Patch(ctx context.Context, key *meta.Key, arg0 *beta.Image) error

+ func (m *MockBetaImages) SetIamPolicy(ctx context.Context, key *meta.Key, arg0 *beta.GlobalSetPolicyRequest) (*beta.Policy, error)

+ func (m *MockBetaImages) SetLabels(ctx context.Context, key *meta.Key, arg0 *beta.GlobalSetLabelsRequest) error

+ func (m *MockBetaImages) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *beta.TestPermissionsRequest) (*beta.TestPermissionsResponse, error)

+ type MockBetaRouters struct

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockBetaRouters) (bool, map[string][]*beta.Router, error)

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaRouters) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaRouters) (bool, *beta.Router, error)

+ GetRouterStatusHook func(context.Context, *meta.Key, *MockBetaRouters) (*beta.RouterStatusResponse, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.Router, m *MockBetaRouters) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockBetaRouters) (bool, []*beta.Router, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRoutersObj

+ PatchHook func(context.Context, *meta.Key, *beta.Router, *MockBetaRouters) error

+ PreviewHook func(context.Context, *meta.Key, *beta.Router, *MockBetaRouters) (*beta.RoutersPreviewResponse, error)

+ ProjectRouter ProjectRouter

+ TestIamPermissionsHook func(context.Context, *meta.Key, *beta.TestPermissionsRequest, *MockBetaRouters) (*beta.TestPermissionsResponse, error)

+ X interface{}

+ func NewMockBetaRouters(pr ProjectRouter, objs map[meta.Key]*MockRoutersObj) *MockBetaRouters

+ func (m *MockBetaRouters) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*beta.Router, error)

+ func (m *MockBetaRouters) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaRouters) Get(ctx context.Context, key *meta.Key) (*beta.Router, error)

+ func (m *MockBetaRouters) GetRouterStatus(ctx context.Context, key *meta.Key) (*beta.RouterStatusResponse, error)

+ func (m *MockBetaRouters) Insert(ctx context.Context, key *meta.Key, obj *beta.Router) error

+ func (m *MockBetaRouters) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Router, error)

+ func (m *MockBetaRouters) Obj(o *beta.Router) *MockRoutersObj

+ func (m *MockBetaRouters) Patch(ctx context.Context, key *meta.Key, arg0 *beta.Router) error

+ func (m *MockBetaRouters) Preview(ctx context.Context, key *meta.Key, arg0 *beta.Router) (*beta.RoutersPreviewResponse, error)

+ func (m *MockBetaRouters) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *beta.TestPermissionsRequest) (*beta.TestPermissionsResponse, error)

type MockBetaSubnetworks

+ PatchHook func(context.Context, *meta.Key, *beta.Subnetwork, *MockBetaSubnetworks) error

+ func (m *MockBetaSubnetworks) Patch(ctx context.Context, key *meta.Key, arg0 *beta.Subnetwork) error

type MockGCE

+ MockAlphaImages *MockAlphaImages

+ MockAlphaNetworkFirewallPolicies *MockAlphaNetworkFirewallPolicies

+ MockAlphaRegionNetworkFirewallPolicies *MockAlphaRegionNetworkFirewallPolicies

+ MockAlphaRouters *MockAlphaRouters

+ MockBetaImages *MockBetaImages

+ MockBetaRouters *MockBetaRouters

+ MockImages *MockImages

+ MockRouters *MockRouters

+ MockTargetTcpProxies *MockTargetTcpProxies

+ func (mock *MockGCE) AlphaImages() AlphaImages

+ func (mock *MockGCE) AlphaNetworkFirewallPolicies() AlphaNetworkFirewallPolicies

+ func (mock *MockGCE) AlphaRegionNetworkFirewallPolicies() AlphaRegionNetworkFirewallPolicies

+ func (mock *MockGCE) AlphaRouters() AlphaRouters

+ func (mock *MockGCE) BetaImages() BetaImages

+ func (mock *MockGCE) BetaRouters() BetaRouters

+ func (mock *MockGCE) Images() Images

+ func (mock *MockGCE) Routers() Routers

+ func (mock *MockGCE) TargetTcpProxies() TargetTcpProxies

+ type MockImages struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockImages) (bool, error)

+ GetError map[meta.Key]error

+ GetFromFamilyHook func(context.Context, *meta.Key, *MockImages) (*ga.Image, error)

+ GetHook func(ctx context.Context, key *meta.Key, m *MockImages) (bool, *ga.Image, error)

+ GetIamPolicyHook func(context.Context, *meta.Key, *MockImages) (*ga.Policy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Image, m *MockImages) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockImages) (bool, []*ga.Image, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockImagesObj

+ PatchHook func(context.Context, *meta.Key, *ga.Image, *MockImages) error

+ ProjectRouter ProjectRouter

+ SetIamPolicyHook func(context.Context, *meta.Key, *ga.GlobalSetPolicyRequest, *MockImages) (*ga.Policy, error)

+ SetLabelsHook func(context.Context, *meta.Key, *ga.GlobalSetLabelsRequest, *MockImages) error

+ TestIamPermissionsHook func(context.Context, *meta.Key, *ga.TestPermissionsRequest, *MockImages) (*ga.TestPermissionsResponse, error)

+ X interface{}

+ func NewMockImages(pr ProjectRouter, objs map[meta.Key]*MockImagesObj) *MockImages

+ func (m *MockImages) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockImages) Get(ctx context.Context, key *meta.Key) (*ga.Image, error)

+ func (m *MockImages) GetFromFamily(ctx context.Context, key *meta.Key) (*ga.Image, error)

+ func (m *MockImages) GetIamPolicy(ctx context.Context, key *meta.Key) (*ga.Policy, error)

+ func (m *MockImages) Insert(ctx context.Context, key *meta.Key, obj *ga.Image) error

+ func (m *MockImages) List(ctx context.Context, fl *filter.F) ([]*ga.Image, error)

+ func (m *MockImages) Obj(o *ga.Image) *MockImagesObj

+ func (m *MockImages) Patch(ctx context.Context, key *meta.Key, arg0 *ga.Image) error

+ func (m *MockImages) SetIamPolicy(ctx context.Context, key *meta.Key, arg0 *ga.GlobalSetPolicyRequest) (*ga.Policy, error)

+ func (m *MockImages) SetLabels(ctx context.Context, key *meta.Key, arg0 *ga.GlobalSetLabelsRequest) error

+ func (m *MockImages) TestIamPermissions(ctx context.Context, key *meta.Key, arg0 *ga.TestPermissionsRequest) (*ga.TestPermissionsResponse, error)

+ type MockImagesObj struct

+ Obj interface{}

+ func (m *MockImagesObj) ToAlpha() *alpha.Image

+ func (m *MockImagesObj) ToBeta() *beta.Image

+ func (m *MockImagesObj) ToGA() *ga.Image

+ type MockNetworkFirewallPoliciesObj struct

+ Obj interface{}

+ func (m *MockNetworkFirewallPoliciesObj) ToAlpha() *alpha.FirewallPolicy

+ type MockRegionNetworkFirewallPoliciesObj struct

+ Obj interface{}

+ func (m *MockRegionNetworkFirewallPoliciesObj) ToAlpha() *alpha.FirewallPolicy

+ type MockRouters struct

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockRouters) (bool, map[string][]*ga.Router, error)

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRouters) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRouters) (bool, *ga.Router, error)

+ GetRouterStatusHook func(context.Context, *meta.Key, *MockRouters) (*ga.RouterStatusResponse, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Router, m *MockRouters) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockRouters) (bool, []*ga.Router, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRoutersObj

+ PatchHook func(context.Context, *meta.Key, *ga.Router, *MockRouters) error

+ PreviewHook func(context.Context, *meta.Key, *ga.Router, *MockRouters) (*ga.RoutersPreviewResponse, error)

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockRouters(pr ProjectRouter, objs map[meta.Key]*MockRoutersObj) *MockRouters

+ func (m *MockRouters) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*ga.Router, error)

+ func (m *MockRouters) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockRouters) Get(ctx context.Context, key *meta.Key) (*ga.Router, error)

+ func (m *MockRouters) GetRouterStatus(ctx context.Context, key *meta.Key) (*ga.RouterStatusResponse, error)

+ func (m *MockRouters) Insert(ctx context.Context, key *meta.Key, obj *ga.Router) error

+ func (m *MockRouters) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Router, error)

+ func (m *MockRouters) Obj(o *ga.Router) *MockRoutersObj

+ func (m *MockRouters) Patch(ctx context.Context, key *meta.Key, arg0 *ga.Router) error

+ func (m *MockRouters) Preview(ctx context.Context, key *meta.Key, arg0 *ga.Router) (*ga.RoutersPreviewResponse, error)

+ type MockRoutersObj struct

+ Obj interface{}

+ func (m *MockRoutersObj) ToAlpha() *alpha.Router

+ func (m *MockRoutersObj) ToBeta() *beta.Router

+ func (m *MockRoutersObj) ToGA() *ga.Router

type MockSubnetworks

+ PatchHook func(context.Context, *meta.Key, *ga.Subnetwork, *MockSubnetworks) error

+ func (m *MockSubnetworks) Patch(ctx context.Context, key *meta.Key, arg0 *ga.Subnetwork) error

+ type MockTargetTcpProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockTargetTcpProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockTargetTcpProxies) (bool, *ga.TargetTcpProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.TargetTcpProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockTargetTcpProxies) (bool, []*ga.TargetTcpProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTargetTcpProxiesObj

+ ProjectRouter ProjectRouter

+ SetBackendServiceHook func(context.Context, *meta.Key, *ga.TargetTcpProxiesSetBackendServiceRequest, ...) error

+ X interface{}

+ func NewMockTargetTcpProxies(pr ProjectRouter, objs map[meta.Key]*MockTargetTcpProxiesObj) *MockTargetTcpProxies

+ func (m *MockTargetTcpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockTargetTcpProxies) Get(ctx context.Context, key *meta.Key) (*ga.TargetTcpProxy, error)

+ func (m *MockTargetTcpProxies) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetTcpProxy) error

+ func (m *MockTargetTcpProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetTcpProxy, error)

+ func (m *MockTargetTcpProxies) Obj(o *ga.TargetTcpProxy) *MockTargetTcpProxiesObj

+ func (m *MockTargetTcpProxies) SetBackendService(ctx context.Context, key *meta.Key, ...) error

type MockTargetTcpProxiesObj

+ func (m *MockTargetTcpProxiesObj) ToGA() *ga.TargetTcpProxy

type ResourceID

+ func NewImagesResourceID(project, name string) *ResourceID

+ func NewNetworkFirewallPoliciesResourceID(project, name string) *ResourceID

+ func NewRegionNetworkFirewallPoliciesResourceID(project, region, name string) *ResourceID

+ func NewRoutersResourceID(project, region, name string) *ResourceID

+ type Routers interface

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*ga.Router, error)

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Router, error)

+ GetRouterStatus func(context.Context, *meta.Key) (*ga.RouterStatusResponse, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Router) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.Router, error)

+ Patch func(context.Context, *meta.Key, *ga.Router) error

+ Preview func(context.Context, *meta.Key, *ga.Router) (*ga.RoutersPreviewResponse, error)

type Subnetworks

+ Patch func(context.Context, *meta.Key, *ga.Subnetwork) error

+ type TargetTcpProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.TargetTcpProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.TargetTcpProxy) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.TargetTcpProxy, error)

+ SetBackendService func(context.Context, *meta.Key, *ga.TargetTcpProxiesSetBackendServiceRequest) error

v1.16.0

May 25, 2021

Changes in this version

type AlphaBackendServices

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*alpha.BackendService, error)

type AlphaSubnetworks

+ ListUsable func(ctx context.Context, fl *filter.F) ([]*alpha.UsableSubnetwork, error)

type BackendServices

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*ga.BackendService, error)

type BetaBackendServices

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*beta.BackendService, error)

type BetaSubnetworks

+ ListUsable func(ctx context.Context, fl *filter.F) ([]*beta.UsableSubnetwork, error)

type GCEAlphaBackendServices

+ func (g *GCEAlphaBackendServices) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.BackendService, error)

type GCEAlphaSubnetworks

+ func (g *GCEAlphaSubnetworks) ListUsable(ctx context.Context, fl *filter.F) ([]*alpha.UsableSubnetwork, error)

type GCEBackendServices

+ func (g *GCEBackendServices) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*ga.BackendService, error)

type GCEBetaBackendServices

+ func (g *GCEBetaBackendServices) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*beta.BackendService, error)

type GCEBetaSubnetworks

+ func (g *GCEBetaSubnetworks) ListUsable(ctx context.Context, fl *filter.F) ([]*beta.UsableSubnetwork, error)

type GCESubnetworks

+ func (g *GCESubnetworks) ListUsable(ctx context.Context, fl *filter.F) ([]*ga.UsableSubnetwork, error)

type MockAlphaBackendServices

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockAlphaBackendServices) (bool, map[string][]*alpha.BackendService, error)

+ func (m *MockAlphaBackendServices) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.BackendService, error)

type MockAlphaSubnetworks

+ ListUsableError *error

+ ListUsableHook func(ctx context.Context, fl *filter.F, m *MockAlphaSubnetworks) (bool, []*alpha.UsableSubnetwork, error)

+ func (m *MockAlphaSubnetworks) ListUsable(ctx context.Context, fl *filter.F) ([]*alpha.UsableSubnetwork, error)

type MockBackendServices

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockBackendServices) (bool, map[string][]*ga.BackendService, error)

+ func (m *MockBackendServices) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*ga.BackendService, error)

type MockBetaBackendServices

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockBetaBackendServices) (bool, map[string][]*beta.BackendService, error)

+ func (m *MockBetaBackendServices) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*beta.BackendService, error)

type MockBetaSubnetworks

+ ListUsableError *error

+ ListUsableHook func(ctx context.Context, fl *filter.F, m *MockBetaSubnetworks) (bool, []*beta.UsableSubnetwork, error)

+ func (m *MockBetaSubnetworks) ListUsable(ctx context.Context, fl *filter.F) ([]*beta.UsableSubnetwork, error)

type MockSubnetworks

+ ListUsableError *error

+ ListUsableHook func(ctx context.Context, fl *filter.F, m *MockSubnetworks) (bool, []*ga.UsableSubnetwork, error)

+ func (m *MockSubnetworks) ListUsable(ctx context.Context, fl *filter.F) ([]*ga.UsableSubnetwork, error)

type Subnetworks

+ ListUsable func(ctx context.Context, fl *filter.F) ([]*ga.UsableSubnetwork, error)

v1.15.0

May 6, 2021

Changes in this version

type AlphaServiceAttachments

+ Patch func(context.Context, *meta.Key, *alpha.ServiceAttachment) error

+ type BetaServiceAttachments interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.ServiceAttachment, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.ServiceAttachment) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.ServiceAttachment, error)

+ Patch func(context.Context, *meta.Key, *beta.ServiceAttachment) error

type Cloud

+ BetaServiceAttachments func() BetaServiceAttachments

type GCE

+ func (gce *GCE) BetaServiceAttachments() BetaServiceAttachments

type GCEAlphaServiceAttachments

+ func (g *GCEAlphaServiceAttachments) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.ServiceAttachment) error

+ type GCEBetaServiceAttachments struct

+ func (g *GCEBetaServiceAttachments) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaServiceAttachments) Get(ctx context.Context, key *meta.Key) (*beta.ServiceAttachment, error)

+ func (g *GCEBetaServiceAttachments) Insert(ctx context.Context, key *meta.Key, obj *beta.ServiceAttachment) error

+ func (g *GCEBetaServiceAttachments) List(ctx context.Context, region string, fl *filter.F) ([]*beta.ServiceAttachment, error)

+ func (g *GCEBetaServiceAttachments) Patch(ctx context.Context, key *meta.Key, arg0 *beta.ServiceAttachment) error

type MockAlphaServiceAttachments

+ PatchHook func(context.Context, *meta.Key, *alpha.ServiceAttachment, ...) error

+ func (m *MockAlphaServiceAttachments) Patch(ctx context.Context, key *meta.Key, arg0 *alpha.ServiceAttachment) error

+ type MockBetaServiceAttachments struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaServiceAttachments) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaServiceAttachments) (bool, *beta.ServiceAttachment, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.ServiceAttachment, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*beta.ServiceAttachment, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockServiceAttachmentsObj

+ PatchHook func(context.Context, *meta.Key, *beta.ServiceAttachment, ...) error

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaServiceAttachments(pr ProjectRouter, objs map[meta.Key]*MockServiceAttachmentsObj) *MockBetaServiceAttachments

+ func (m *MockBetaServiceAttachments) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaServiceAttachments) Get(ctx context.Context, key *meta.Key) (*beta.ServiceAttachment, error)

+ func (m *MockBetaServiceAttachments) Insert(ctx context.Context, key *meta.Key, obj *beta.ServiceAttachment) error

+ func (m *MockBetaServiceAttachments) List(ctx context.Context, region string, fl *filter.F) ([]*beta.ServiceAttachment, error)

+ func (m *MockBetaServiceAttachments) Obj(o *beta.ServiceAttachment) *MockServiceAttachmentsObj

+ func (m *MockBetaServiceAttachments) Patch(ctx context.Context, key *meta.Key, arg0 *beta.ServiceAttachment) error

type MockGCE

+ MockBetaServiceAttachments *MockBetaServiceAttachments

+ func (mock *MockGCE) BetaServiceAttachments() BetaServiceAttachments

type MockServiceAttachmentsObj

+ func (m *MockServiceAttachmentsObj) ToBeta() *beta.ServiceAttachment

v1.14.0

Dec 30, 2020

Changes in this version

+ const NetworkTierDefault

+ const NetworkTierPremium

+ const NetworkTierStandard

+ const SchemeExternal

+ const SchemeInternal

+ func ContextWithCallTimeout() (context.Context, context.CancelFunc)

+ func RelativeResourceName(project, resource string, key *meta.Key) string

+ func ResourcePath(resource string, key *meta.Key) string

+ func SelfLink(ver meta.Version, project, resource string, key *meta.Key) string

+ type AcceptRateLimiter struct

+ Acceptor acceptor

+ func (rl *AcceptRateLimiter) Accept(ctx context.Context, key *RateLimitKey) error

+ type Addresses interface

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*ga.Address, error)

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Address, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Address) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.Address, error)

+ type AlphaAddresses interface

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*alpha.Address, error)

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.Address, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.Address) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.Address, error)

+ type AlphaBackendServices interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.BackendService, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.BackendService) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.BackendService, error)

+ SetSecurityPolicy func(context.Context, *meta.Key, *alpha.SecurityPolicyReference) error

+ Update func(context.Context, *meta.Key, *alpha.BackendService) error

+ type AlphaFirewalls interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.Firewall, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.Firewall) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.Firewall, error)

+ Update func(context.Context, *meta.Key, *alpha.Firewall) error

+ type AlphaForwardingRules interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.ForwardingRule, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.ForwardingRule) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.ForwardingRule, error)

+ SetTarget func(context.Context, *meta.Key, *alpha.TargetReference) error

+ type AlphaGlobalAddresses interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.Address, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.Address) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.Address, error)

+ type AlphaGlobalForwardingRules interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.ForwardingRule, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.ForwardingRule) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.ForwardingRule, error)

+ SetTarget func(context.Context, *meta.Key, *alpha.TargetReference) error

+ type AlphaHealthChecks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.HealthCheck, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.HealthCheck) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.HealthCheck, error)

+ Update func(context.Context, *meta.Key, *alpha.HealthCheck) error

+ type AlphaInstances interface

+ AttachDisk func(context.Context, *meta.Key, *alpha.AttachedDisk) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ DetachDisk func(context.Context, *meta.Key, string) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.Instance, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.Instance) error

+ List func(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Instance, error)

+ UpdateNetworkInterface func(context.Context, *meta.Key, string, *alpha.NetworkInterface) error

+ type AlphaNetworkEndpointGroups interface

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*alpha.NetworkEndpointGroup, error)

+ AttachNetworkEndpoints func(context.Context, *meta.Key, *alpha.NetworkEndpointGroupsAttachEndpointsRequest) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ DetachNetworkEndpoints func(context.Context, *meta.Key, *alpha.NetworkEndpointGroupsDetachEndpointsRequest) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.NetworkEndpointGroup, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.NetworkEndpointGroup) error

+ List func(ctx context.Context, zone string, fl *filter.F) ([]*alpha.NetworkEndpointGroup, error)

+ ListNetworkEndpoints func(context.Context, *meta.Key, *alpha.NetworkEndpointGroupsListEndpointsRequest, ...) ([]*alpha.NetworkEndpointWithHealthStatus, error)

+ type AlphaNetworks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.Network, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.Network) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.Network, error)

+ type AlphaRegionBackendServices interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.BackendService, error)

+ GetHealth func(context.Context, *meta.Key, *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.BackendService) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.BackendService, error)

+ Update func(context.Context, *meta.Key, *alpha.BackendService) error

+ type AlphaRegionHealthChecks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.HealthCheck, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.HealthCheck) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.HealthCheck, error)

+ Update func(context.Context, *meta.Key, *alpha.HealthCheck) error

+ type AlphaRegionSslCertificates interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.SslCertificate, error)

+ type AlphaRegionTargetHttpProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.TargetHttpProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpProxy) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.TargetHttpProxy, error)

+ SetUrlMap func(context.Context, *meta.Key, *alpha.UrlMapReference) error

+ type AlphaRegionTargetHttpsProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.TargetHttpsProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpsProxy) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.TargetHttpsProxy, error)

+ SetSslCertificates func(context.Context, *meta.Key, ...) error

+ SetUrlMap func(context.Context, *meta.Key, *alpha.UrlMapReference) error

+ type AlphaRegionUrlMaps interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.UrlMap, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.UrlMap) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.UrlMap, error)

+ Update func(context.Context, *meta.Key, *alpha.UrlMap) error

+ type AlphaServiceAttachments interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.ServiceAttachment, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.ServiceAttachment) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.ServiceAttachment, error)

+ type AlphaSslCertificates interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.SslCertificate, error)

+ type AlphaSubnetworks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.Subnetwork, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*alpha.Subnetwork, error)

+ type AlphaTargetHttpProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.TargetHttpProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpProxy) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.TargetHttpProxy, error)

+ SetUrlMap func(context.Context, *meta.Key, *alpha.UrlMapReference) error

+ type AlphaTargetHttpsProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.TargetHttpsProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpsProxy) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.TargetHttpsProxy, error)

+ SetSslCertificates func(context.Context, *meta.Key, *alpha.TargetHttpsProxiesSetSslCertificatesRequest) error

+ SetSslPolicy func(context.Context, *meta.Key, *alpha.SslPolicyReference) error

+ SetUrlMap func(context.Context, *meta.Key, *alpha.UrlMapReference) error

+ type AlphaTargetTcpProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.TargetTcpProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.TargetTcpProxy) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.TargetTcpProxy, error)

+ SetBackendService func(context.Context, *meta.Key, *alpha.TargetTcpProxiesSetBackendServiceRequest) error

+ type AlphaUrlMaps interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*alpha.UrlMap, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *alpha.UrlMap) error

+ List func(ctx context.Context, fl *filter.F) ([]*alpha.UrlMap, error)

+ Update func(context.Context, *meta.Key, *alpha.UrlMap) error

+ type BackendServices interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.BackendService, error)

+ GetHealth func(context.Context, *meta.Key, *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.BackendService) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.BackendService, error)

+ Patch func(context.Context, *meta.Key, *ga.BackendService) error

+ SetSecurityPolicy func(context.Context, *meta.Key, *ga.SecurityPolicyReference) error

+ Update func(context.Context, *meta.Key, *ga.BackendService) error

+ type BetaAddresses interface

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*beta.Address, error)

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.Address, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.Address) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.Address, error)

+ type BetaBackendServices interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.BackendService, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.BackendService) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.BackendService, error)

+ SetSecurityPolicy func(context.Context, *meta.Key, *beta.SecurityPolicyReference) error

+ Update func(context.Context, *meta.Key, *beta.BackendService) error

+ type BetaFirewalls interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.Firewall, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.Firewall) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.Firewall, error)

+ Update func(context.Context, *meta.Key, *beta.Firewall) error

+ type BetaForwardingRules interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.ForwardingRule, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.ForwardingRule, error)

+ SetTarget func(context.Context, *meta.Key, *beta.TargetReference) error

+ type BetaGlobalAddresses interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.Address, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.Address) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.Address, error)

+ type BetaGlobalForwardingRules interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.ForwardingRule, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.ForwardingRule, error)

+ SetTarget func(context.Context, *meta.Key, *beta.TargetReference) error

+ type BetaHealthChecks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.HealthCheck, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.HealthCheck) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.HealthCheck, error)

+ Update func(context.Context, *meta.Key, *beta.HealthCheck) error

+ type BetaInstances interface

+ AttachDisk func(context.Context, *meta.Key, *beta.AttachedDisk) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ DetachDisk func(context.Context, *meta.Key, string) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.Instance, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.Instance) error

+ List func(ctx context.Context, zone string, fl *filter.F) ([]*beta.Instance, error)

+ UpdateNetworkInterface func(context.Context, *meta.Key, string, *beta.NetworkInterface) error

+ type BetaNetworkEndpointGroups interface

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*beta.NetworkEndpointGroup, error)

+ AttachNetworkEndpoints func(context.Context, *meta.Key, *beta.NetworkEndpointGroupsAttachEndpointsRequest) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ DetachNetworkEndpoints func(context.Context, *meta.Key, *beta.NetworkEndpointGroupsDetachEndpointsRequest) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.NetworkEndpointGroup, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.NetworkEndpointGroup) error

+ List func(ctx context.Context, zone string, fl *filter.F) ([]*beta.NetworkEndpointGroup, error)

+ ListNetworkEndpoints func(context.Context, *meta.Key, *beta.NetworkEndpointGroupsListEndpointsRequest, ...) ([]*beta.NetworkEndpointWithHealthStatus, error)

+ type BetaNetworks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.Network, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.Network) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.Network, error)

+ type BetaRegionBackendServices interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.BackendService, error)

+ GetHealth func(context.Context, *meta.Key, *beta.ResourceGroupReference) (*beta.BackendServiceGroupHealth, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.BackendService) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.BackendService, error)

+ Update func(context.Context, *meta.Key, *beta.BackendService) error

+ type BetaRegionHealthChecks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.HealthCheck, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.HealthCheck) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.HealthCheck, error)

+ Update func(context.Context, *meta.Key, *beta.HealthCheck) error

+ type BetaRegionSslCertificates interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.SslCertificate, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.SslCertificate) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.SslCertificate, error)

+ type BetaRegionTargetHttpProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.TargetHttpProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.TargetHttpProxy) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.TargetHttpProxy, error)

+ SetUrlMap func(context.Context, *meta.Key, *beta.UrlMapReference) error

+ type BetaRegionTargetHttpsProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.TargetHttpsProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.TargetHttpsProxy) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.TargetHttpsProxy, error)

+ SetSslCertificates func(context.Context, *meta.Key, ...) error

+ SetUrlMap func(context.Context, *meta.Key, *beta.UrlMapReference) error

+ type BetaRegionUrlMaps interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.UrlMap, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.UrlMap) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.UrlMap, error)

+ Update func(context.Context, *meta.Key, *beta.UrlMap) error

+ type BetaSecurityPolicies interface

+ AddRule func(context.Context, *meta.Key, *beta.SecurityPolicyRule) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.SecurityPolicy, error)

+ GetRule func(context.Context, *meta.Key) (*beta.SecurityPolicyRule, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.SecurityPolicy) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.SecurityPolicy, error)

+ Patch func(context.Context, *meta.Key, *beta.SecurityPolicy) error

+ PatchRule func(context.Context, *meta.Key, *beta.SecurityPolicyRule) error

+ RemoveRule func(context.Context, *meta.Key) error

+ type BetaSslCertificates interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.SslCertificate, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.SslCertificate) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.SslCertificate, error)

+ type BetaSubnetworks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.Subnetwork, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.Subnetwork) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*beta.Subnetwork, error)

+ type BetaTargetHttpProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.TargetHttpProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.TargetHttpProxy) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.TargetHttpProxy, error)

+ SetUrlMap func(context.Context, *meta.Key, *beta.UrlMapReference) error

+ type BetaTargetHttpsProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.TargetHttpsProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.TargetHttpsProxy) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.TargetHttpsProxy, error)

+ SetSslCertificates func(context.Context, *meta.Key, *beta.TargetHttpsProxiesSetSslCertificatesRequest) error

+ SetSslPolicy func(context.Context, *meta.Key, *beta.SslPolicyReference) error

+ SetUrlMap func(context.Context, *meta.Key, *beta.UrlMapReference) error

+ type BetaTargetTcpProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.TargetTcpProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.TargetTcpProxy) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.TargetTcpProxy, error)

+ SetBackendService func(context.Context, *meta.Key, *beta.TargetTcpProxiesSetBackendServiceRequest) error

+ type BetaUrlMaps interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*beta.UrlMap, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *beta.UrlMap) error

+ List func(ctx context.Context, fl *filter.F) ([]*beta.UrlMap, error)

+ Update func(context.Context, *meta.Key, *beta.UrlMap) error

+ type Cloud interface

+ Addresses func() Addresses

+ AlphaAddresses func() AlphaAddresses

+ AlphaBackendServices func() AlphaBackendServices

+ AlphaFirewalls func() AlphaFirewalls

+ AlphaForwardingRules func() AlphaForwardingRules

+ AlphaGlobalAddresses func() AlphaGlobalAddresses

+ AlphaGlobalForwardingRules func() AlphaGlobalForwardingRules

+ AlphaHealthChecks func() AlphaHealthChecks

+ AlphaInstances func() AlphaInstances

+ AlphaNetworkEndpointGroups func() AlphaNetworkEndpointGroups

+ AlphaNetworks func() AlphaNetworks

+ AlphaRegionBackendServices func() AlphaRegionBackendServices

+ AlphaRegionHealthChecks func() AlphaRegionHealthChecks

+ AlphaRegionSslCertificates func() AlphaRegionSslCertificates

+ AlphaRegionTargetHttpProxies func() AlphaRegionTargetHttpProxies

+ AlphaRegionTargetHttpsProxies func() AlphaRegionTargetHttpsProxies

+ AlphaRegionUrlMaps func() AlphaRegionUrlMaps

+ AlphaServiceAttachments func() AlphaServiceAttachments

+ AlphaSslCertificates func() AlphaSslCertificates

+ AlphaSubnetworks func() AlphaSubnetworks

+ AlphaTargetHttpProxies func() AlphaTargetHttpProxies

+ AlphaTargetHttpsProxies func() AlphaTargetHttpsProxies

+ AlphaTargetTcpProxies func() AlphaTargetTcpProxies

+ AlphaUrlMaps func() AlphaUrlMaps

+ BackendServices func() BackendServices

+ BetaAddresses func() BetaAddresses

+ BetaBackendServices func() BetaBackendServices

+ BetaFirewalls func() BetaFirewalls

+ BetaForwardingRules func() BetaForwardingRules

+ BetaGlobalAddresses func() BetaGlobalAddresses

+ BetaGlobalForwardingRules func() BetaGlobalForwardingRules

+ BetaHealthChecks func() BetaHealthChecks

+ BetaInstances func() BetaInstances

+ BetaNetworkEndpointGroups func() BetaNetworkEndpointGroups

+ BetaNetworks func() BetaNetworks

+ BetaRegionBackendServices func() BetaRegionBackendServices

+ BetaRegionHealthChecks func() BetaRegionHealthChecks

+ BetaRegionSslCertificates func() BetaRegionSslCertificates

+ BetaRegionTargetHttpProxies func() BetaRegionTargetHttpProxies

+ BetaRegionTargetHttpsProxies func() BetaRegionTargetHttpsProxies

+ BetaRegionUrlMaps func() BetaRegionUrlMaps

+ BetaSecurityPolicies func() BetaSecurityPolicies

+ BetaSslCertificates func() BetaSslCertificates

+ BetaSubnetworks func() BetaSubnetworks

+ BetaTargetHttpProxies func() BetaTargetHttpProxies

+ BetaTargetHttpsProxies func() BetaTargetHttpsProxies

+ BetaTargetTcpProxies func() BetaTargetTcpProxies

+ BetaUrlMaps func() BetaUrlMaps

+ Disks func() Disks

+ Firewalls func() Firewalls

+ ForwardingRules func() ForwardingRules

+ GlobalAddresses func() GlobalAddresses

+ GlobalForwardingRules func() GlobalForwardingRules

+ HealthChecks func() HealthChecks

+ HttpHealthChecks func() HttpHealthChecks

+ HttpsHealthChecks func() HttpsHealthChecks

+ InstanceGroups func() InstanceGroups

+ Instances func() Instances

+ NetworkEndpointGroups func() NetworkEndpointGroups

+ Networks func() Networks

+ Projects func() Projects

+ RegionBackendServices func() RegionBackendServices

+ RegionDisks func() RegionDisks

+ RegionHealthChecks func() RegionHealthChecks

+ RegionSslCertificates func() RegionSslCertificates

+ RegionTargetHttpProxies func() RegionTargetHttpProxies

+ RegionTargetHttpsProxies func() RegionTargetHttpsProxies

+ RegionUrlMaps func() RegionUrlMaps

+ Regions func() Regions

+ Routes func() Routes

+ SslCertificates func() SslCertificates

+ SslPolicies func() SslPolicies

+ Subnetworks func() Subnetworks

+ TargetHttpProxies func() TargetHttpProxies

+ TargetHttpsProxies func() TargetHttpsProxies

+ TargetPools func() TargetPools

+ UrlMaps func() UrlMaps

+ Zones func() Zones

+ type Disks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Disk, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Disk) error

+ List func(ctx context.Context, zone string, fl *filter.F) ([]*ga.Disk, error)

+ Resize func(context.Context, *meta.Key, *ga.DisksResizeRequest) error

+ type Firewalls interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Firewall, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Firewall) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.Firewall, error)

+ Update func(context.Context, *meta.Key, *ga.Firewall) error

+ type ForwardingRules interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.ForwardingRule, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.ForwardingRule) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.ForwardingRule, error)

+ SetTarget func(context.Context, *meta.Key, *ga.TargetReference) error

+ type GCE struct

+ func NewGCE(s *Service) *GCE

+ func (gce *GCE) Addresses() Addresses

+ func (gce *GCE) AlphaAddresses() AlphaAddresses

+ func (gce *GCE) AlphaBackendServices() AlphaBackendServices

+ func (gce *GCE) AlphaFirewalls() AlphaFirewalls

+ func (gce *GCE) AlphaForwardingRules() AlphaForwardingRules

+ func (gce *GCE) AlphaGlobalAddresses() AlphaGlobalAddresses

+ func (gce *GCE) AlphaGlobalForwardingRules() AlphaGlobalForwardingRules

+ func (gce *GCE) AlphaHealthChecks() AlphaHealthChecks

+ func (gce *GCE) AlphaInstances() AlphaInstances

+ func (gce *GCE) AlphaNetworkEndpointGroups() AlphaNetworkEndpointGroups

+ func (gce *GCE) AlphaNetworks() AlphaNetworks

+ func (gce *GCE) AlphaRegionBackendServices() AlphaRegionBackendServices

+ func (gce *GCE) AlphaRegionHealthChecks() AlphaRegionHealthChecks

+ func (gce *GCE) AlphaRegionSslCertificates() AlphaRegionSslCertificates

+ func (gce *GCE) AlphaRegionTargetHttpProxies() AlphaRegionTargetHttpProxies

+ func (gce *GCE) AlphaRegionTargetHttpsProxies() AlphaRegionTargetHttpsProxies

+ func (gce *GCE) AlphaRegionUrlMaps() AlphaRegionUrlMaps

+ func (gce *GCE) AlphaServiceAttachments() AlphaServiceAttachments

+ func (gce *GCE) AlphaSslCertificates() AlphaSslCertificates

+ func (gce *GCE) AlphaSubnetworks() AlphaSubnetworks

+ func (gce *GCE) AlphaTargetHttpProxies() AlphaTargetHttpProxies

+ func (gce *GCE) AlphaTargetHttpsProxies() AlphaTargetHttpsProxies

+ func (gce *GCE) AlphaTargetTcpProxies() AlphaTargetTcpProxies

+ func (gce *GCE) AlphaUrlMaps() AlphaUrlMaps

+ func (gce *GCE) BackendServices() BackendServices

+ func (gce *GCE) BetaAddresses() BetaAddresses

+ func (gce *GCE) BetaBackendServices() BetaBackendServices

+ func (gce *GCE) BetaFirewalls() BetaFirewalls

+ func (gce *GCE) BetaForwardingRules() BetaForwardingRules

+ func (gce *GCE) BetaGlobalAddresses() BetaGlobalAddresses

+ func (gce *GCE) BetaGlobalForwardingRules() BetaGlobalForwardingRules

+ func (gce *GCE) BetaHealthChecks() BetaHealthChecks

+ func (gce *GCE) BetaInstances() BetaInstances

+ func (gce *GCE) BetaNetworkEndpointGroups() BetaNetworkEndpointGroups

+ func (gce *GCE) BetaNetworks() BetaNetworks

+ func (gce *GCE) BetaRegionBackendServices() BetaRegionBackendServices

+ func (gce *GCE) BetaRegionHealthChecks() BetaRegionHealthChecks

+ func (gce *GCE) BetaRegionSslCertificates() BetaRegionSslCertificates

+ func (gce *GCE) BetaRegionTargetHttpProxies() BetaRegionTargetHttpProxies

+ func (gce *GCE) BetaRegionTargetHttpsProxies() BetaRegionTargetHttpsProxies

+ func (gce *GCE) BetaRegionUrlMaps() BetaRegionUrlMaps

+ func (gce *GCE) BetaSecurityPolicies() BetaSecurityPolicies

+ func (gce *GCE) BetaSslCertificates() BetaSslCertificates

+ func (gce *GCE) BetaSubnetworks() BetaSubnetworks

+ func (gce *GCE) BetaTargetHttpProxies() BetaTargetHttpProxies

+ func (gce *GCE) BetaTargetHttpsProxies() BetaTargetHttpsProxies

+ func (gce *GCE) BetaTargetTcpProxies() BetaTargetTcpProxies

+ func (gce *GCE) BetaUrlMaps() BetaUrlMaps

+ func (gce *GCE) Disks() Disks

+ func (gce *GCE) Firewalls() Firewalls

+ func (gce *GCE) ForwardingRules() ForwardingRules

+ func (gce *GCE) GlobalAddresses() GlobalAddresses

+ func (gce *GCE) GlobalForwardingRules() GlobalForwardingRules

+ func (gce *GCE) HealthChecks() HealthChecks

+ func (gce *GCE) HttpHealthChecks() HttpHealthChecks

+ func (gce *GCE) HttpsHealthChecks() HttpsHealthChecks

+ func (gce *GCE) InstanceGroups() InstanceGroups

+ func (gce *GCE) Instances() Instances

+ func (gce *GCE) NetworkEndpointGroups() NetworkEndpointGroups

+ func (gce *GCE) Networks() Networks

+ func (gce *GCE) Projects() Projects

+ func (gce *GCE) RegionBackendServices() RegionBackendServices

+ func (gce *GCE) RegionDisks() RegionDisks

+ func (gce *GCE) RegionHealthChecks() RegionHealthChecks

+ func (gce *GCE) RegionSslCertificates() RegionSslCertificates

+ func (gce *GCE) RegionTargetHttpProxies() RegionTargetHttpProxies

+ func (gce *GCE) RegionTargetHttpsProxies() RegionTargetHttpsProxies

+ func (gce *GCE) RegionUrlMaps() RegionUrlMaps

+ func (gce *GCE) Regions() Regions

+ func (gce *GCE) Routes() Routes

+ func (gce *GCE) SslCertificates() SslCertificates

+ func (gce *GCE) SslPolicies() SslPolicies

+ func (gce *GCE) Subnetworks() Subnetworks

+ func (gce *GCE) TargetHttpProxies() TargetHttpProxies

+ func (gce *GCE) TargetHttpsProxies() TargetHttpsProxies

+ func (gce *GCE) TargetPools() TargetPools

+ func (gce *GCE) UrlMaps() UrlMaps

+ func (gce *GCE) Zones() Zones

+ type GCEAddresses struct

+ func (g *GCEAddresses) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*ga.Address, error)

+ func (g *GCEAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAddresses) Get(ctx context.Context, key *meta.Key) (*ga.Address, error)

+ func (g *GCEAddresses) Insert(ctx context.Context, key *meta.Key, obj *ga.Address) error

+ func (g *GCEAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Address, error)

+ type GCEAlphaAddresses struct

+ func (g *GCEAlphaAddresses) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.Address, error)

+ func (g *GCEAlphaAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaAddresses) Get(ctx context.Context, key *meta.Key) (*alpha.Address, error)

+ func (g *GCEAlphaAddresses) Insert(ctx context.Context, key *meta.Key, obj *alpha.Address) error

+ func (g *GCEAlphaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Address, error)

+ type GCEAlphaBackendServices struct

+ func (g *GCEAlphaBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaBackendServices) Get(ctx context.Context, key *meta.Key) (*alpha.BackendService, error)

+ func (g *GCEAlphaBackendServices) Insert(ctx context.Context, key *meta.Key, obj *alpha.BackendService) error

+ func (g *GCEAlphaBackendServices) List(ctx context.Context, fl *filter.F) ([]*alpha.BackendService, error)

+ func (g *GCEAlphaBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *alpha.SecurityPolicyReference) error

+ func (g *GCEAlphaBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *alpha.BackendService) error

+ type GCEAlphaFirewalls struct

+ func (g *GCEAlphaFirewalls) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaFirewalls) Get(ctx context.Context, key *meta.Key) (*alpha.Firewall, error)

+ func (g *GCEAlphaFirewalls) Insert(ctx context.Context, key *meta.Key, obj *alpha.Firewall) error

+ func (g *GCEAlphaFirewalls) List(ctx context.Context, fl *filter.F) ([]*alpha.Firewall, error)

+ func (g *GCEAlphaFirewalls) Update(ctx context.Context, key *meta.Key, arg0 *alpha.Firewall) error

+ type GCEAlphaForwardingRules struct

+ func (g *GCEAlphaForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaForwardingRules) Get(ctx context.Context, key *meta.Key) (*alpha.ForwardingRule, error)

+ func (g *GCEAlphaForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *alpha.ForwardingRule) error

+ func (g *GCEAlphaForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.ForwardingRule, error)

+ func (g *GCEAlphaForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *alpha.TargetReference) error

+ type GCEAlphaGlobalAddresses struct

+ func (g *GCEAlphaGlobalAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaGlobalAddresses) Get(ctx context.Context, key *meta.Key) (*alpha.Address, error)

+ func (g *GCEAlphaGlobalAddresses) Insert(ctx context.Context, key *meta.Key, obj *alpha.Address) error

+ func (g *GCEAlphaGlobalAddresses) List(ctx context.Context, fl *filter.F) ([]*alpha.Address, error)

+ type GCEAlphaGlobalForwardingRules struct

+ func (g *GCEAlphaGlobalForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaGlobalForwardingRules) Get(ctx context.Context, key *meta.Key) (*alpha.ForwardingRule, error)

+ func (g *GCEAlphaGlobalForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *alpha.ForwardingRule) error

+ func (g *GCEAlphaGlobalForwardingRules) List(ctx context.Context, fl *filter.F) ([]*alpha.ForwardingRule, error)

+ func (g *GCEAlphaGlobalForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *alpha.TargetReference) error

+ type GCEAlphaHealthChecks struct

+ func (g *GCEAlphaHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaHealthChecks) Get(ctx context.Context, key *meta.Key) (*alpha.HealthCheck, error)

+ func (g *GCEAlphaHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *alpha.HealthCheck) error

+ func (g *GCEAlphaHealthChecks) List(ctx context.Context, fl *filter.F) ([]*alpha.HealthCheck, error)

+ func (g *GCEAlphaHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *alpha.HealthCheck) error

+ type GCEAlphaInstances struct

+ func (g *GCEAlphaInstances) AttachDisk(ctx context.Context, key *meta.Key, arg0 *alpha.AttachedDisk) error

+ func (g *GCEAlphaInstances) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaInstances) DetachDisk(ctx context.Context, key *meta.Key, arg0 string) error

+ func (g *GCEAlphaInstances) Get(ctx context.Context, key *meta.Key) (*alpha.Instance, error)

+ func (g *GCEAlphaInstances) Insert(ctx context.Context, key *meta.Key, obj *alpha.Instance) error

+ func (g *GCEAlphaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Instance, error)

+ func (g *GCEAlphaInstances) UpdateNetworkInterface(ctx context.Context, key *meta.Key, arg0 string, arg1 *alpha.NetworkInterface) error

+ type GCEAlphaNetworkEndpointGroups struct

+ func (g *GCEAlphaNetworkEndpointGroups) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.NetworkEndpointGroup, error)

+ func (g *GCEAlphaNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEAlphaNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEAlphaNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key) (*alpha.NetworkEndpointGroup, error)

+ func (g *GCEAlphaNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *alpha.NetworkEndpointGroup) error

+ func (g *GCEAlphaNetworkEndpointGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.NetworkEndpointGroup, error)

+ func (g *GCEAlphaNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, ...) ([]*alpha.NetworkEndpointWithHealthStatus, error)

+ type GCEAlphaNetworks struct

+ func (g *GCEAlphaNetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaNetworks) Get(ctx context.Context, key *meta.Key) (*alpha.Network, error)

+ func (g *GCEAlphaNetworks) Insert(ctx context.Context, key *meta.Key, obj *alpha.Network) error

+ func (g *GCEAlphaNetworks) List(ctx context.Context, fl *filter.F) ([]*alpha.Network, error)

+ type GCEAlphaRegionBackendServices struct

+ func (g *GCEAlphaRegionBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRegionBackendServices) Get(ctx context.Context, key *meta.Key) (*alpha.BackendService, error)

+ func (g *GCEAlphaRegionBackendServices) GetHealth(ctx context.Context, key *meta.Key, arg0 *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error)

+ func (g *GCEAlphaRegionBackendServices) Insert(ctx context.Context, key *meta.Key, obj *alpha.BackendService) error

+ func (g *GCEAlphaRegionBackendServices) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.BackendService, error)

+ func (g *GCEAlphaRegionBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *alpha.BackendService) error

+ type GCEAlphaRegionHealthChecks struct

+ func (g *GCEAlphaRegionHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRegionHealthChecks) Get(ctx context.Context, key *meta.Key) (*alpha.HealthCheck, error)

+ func (g *GCEAlphaRegionHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *alpha.HealthCheck) error

+ func (g *GCEAlphaRegionHealthChecks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.HealthCheck, error)

+ func (g *GCEAlphaRegionHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *alpha.HealthCheck) error

+ type GCEAlphaRegionSslCertificates struct

+ func (g *GCEAlphaRegionSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRegionSslCertificates) Get(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error)

+ func (g *GCEAlphaRegionSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error

+ func (g *GCEAlphaRegionSslCertificates) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.SslCertificate, error)

+ type GCEAlphaRegionTargetHttpProxies struct

+ func (g *GCEAlphaRegionTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRegionTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*alpha.TargetHttpProxy, error)

+ func (g *GCEAlphaRegionTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpProxy) error

+ func (g *GCEAlphaRegionTargetHttpProxies) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.TargetHttpProxy, error)

+ func (g *GCEAlphaRegionTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMapReference) error

+ type GCEAlphaRegionTargetHttpsProxies struct

+ func (g *GCEAlphaRegionTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRegionTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*alpha.TargetHttpsProxy, error)

+ func (g *GCEAlphaRegionTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpsProxy) error

+ func (g *GCEAlphaRegionTargetHttpsProxies) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.TargetHttpsProxy, error)

+ func (g *GCEAlphaRegionTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEAlphaRegionTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMapReference) error

+ type GCEAlphaRegionUrlMaps struct

+ func (g *GCEAlphaRegionUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaRegionUrlMaps) Get(ctx context.Context, key *meta.Key) (*alpha.UrlMap, error)

+ func (g *GCEAlphaRegionUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *alpha.UrlMap) error

+ func (g *GCEAlphaRegionUrlMaps) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.UrlMap, error)

+ func (g *GCEAlphaRegionUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMap) error

+ type GCEAlphaServiceAttachments struct

+ func (g *GCEAlphaServiceAttachments) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaServiceAttachments) Get(ctx context.Context, key *meta.Key) (*alpha.ServiceAttachment, error)

+ func (g *GCEAlphaServiceAttachments) Insert(ctx context.Context, key *meta.Key, obj *alpha.ServiceAttachment) error

+ func (g *GCEAlphaServiceAttachments) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.ServiceAttachment, error)

+ type GCEAlphaSslCertificates struct

+ func (g *GCEAlphaSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaSslCertificates) Get(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error)

+ func (g *GCEAlphaSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error

+ func (g *GCEAlphaSslCertificates) List(ctx context.Context, fl *filter.F) ([]*alpha.SslCertificate, error)

+ type GCEAlphaSubnetworks struct

+ func (g *GCEAlphaSubnetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaSubnetworks) Get(ctx context.Context, key *meta.Key) (*alpha.Subnetwork, error)

+ func (g *GCEAlphaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork) error

+ func (g *GCEAlphaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Subnetwork, error)

+ type GCEAlphaTargetHttpProxies struct

+ func (g *GCEAlphaTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*alpha.TargetHttpProxy, error)

+ func (g *GCEAlphaTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpProxy) error

+ func (g *GCEAlphaTargetHttpProxies) List(ctx context.Context, fl *filter.F) ([]*alpha.TargetHttpProxy, error)

+ func (g *GCEAlphaTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMapReference) error

+ type GCEAlphaTargetHttpsProxies struct

+ func (g *GCEAlphaTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*alpha.TargetHttpsProxy, error)

+ func (g *GCEAlphaTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpsProxy) error

+ func (g *GCEAlphaTargetHttpsProxies) List(ctx context.Context, fl *filter.F) ([]*alpha.TargetHttpsProxy, error)

+ func (g *GCEAlphaTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEAlphaTargetHttpsProxies) SetSslPolicy(ctx context.Context, key *meta.Key, arg0 *alpha.SslPolicyReference) error

+ func (g *GCEAlphaTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMapReference) error

+ type GCEAlphaTargetTcpProxies struct

+ func (g *GCEAlphaTargetTcpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaTargetTcpProxies) Get(ctx context.Context, key *meta.Key) (*alpha.TargetTcpProxy, error)

+ func (g *GCEAlphaTargetTcpProxies) Insert(ctx context.Context, key *meta.Key, obj *alpha.TargetTcpProxy) error

+ func (g *GCEAlphaTargetTcpProxies) List(ctx context.Context, fl *filter.F) ([]*alpha.TargetTcpProxy, error)

+ func (g *GCEAlphaTargetTcpProxies) SetBackendService(ctx context.Context, key *meta.Key, ...) error

+ type GCEAlphaUrlMaps struct

+ func (g *GCEAlphaUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEAlphaUrlMaps) Get(ctx context.Context, key *meta.Key) (*alpha.UrlMap, error)

+ func (g *GCEAlphaUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *alpha.UrlMap) error

+ func (g *GCEAlphaUrlMaps) List(ctx context.Context, fl *filter.F) ([]*alpha.UrlMap, error)

+ func (g *GCEAlphaUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMap) error

+ type GCEBackendServices struct

+ func (g *GCEBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBackendServices) Get(ctx context.Context, key *meta.Key) (*ga.BackendService, error)

+ func (g *GCEBackendServices) GetHealth(ctx context.Context, key *meta.Key, arg0 *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error)

+ func (g *GCEBackendServices) Insert(ctx context.Context, key *meta.Key, obj *ga.BackendService) error

+ func (g *GCEBackendServices) List(ctx context.Context, fl *filter.F) ([]*ga.BackendService, error)

+ func (g *GCEBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *ga.BackendService) error

+ func (g *GCEBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *ga.SecurityPolicyReference) error

+ func (g *GCEBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *ga.BackendService) error

+ type GCEBetaAddresses struct

+ func (g *GCEBetaAddresses) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*beta.Address, error)

+ func (g *GCEBetaAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaAddresses) Get(ctx context.Context, key *meta.Key) (*beta.Address, error)

+ func (g *GCEBetaAddresses) Insert(ctx context.Context, key *meta.Key, obj *beta.Address) error

+ func (g *GCEBetaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Address, error)

+ type GCEBetaBackendServices struct

+ func (g *GCEBetaBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaBackendServices) Get(ctx context.Context, key *meta.Key) (*beta.BackendService, error)

+ func (g *GCEBetaBackendServices) Insert(ctx context.Context, key *meta.Key, obj *beta.BackendService) error

+ func (g *GCEBetaBackendServices) List(ctx context.Context, fl *filter.F) ([]*beta.BackendService, error)

+ func (g *GCEBetaBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *beta.SecurityPolicyReference) error

+ func (g *GCEBetaBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *beta.BackendService) error

+ type GCEBetaFirewalls struct

+ func (g *GCEBetaFirewalls) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaFirewalls) Get(ctx context.Context, key *meta.Key) (*beta.Firewall, error)

+ func (g *GCEBetaFirewalls) Insert(ctx context.Context, key *meta.Key, obj *beta.Firewall) error

+ func (g *GCEBetaFirewalls) List(ctx context.Context, fl *filter.F) ([]*beta.Firewall, error)

+ func (g *GCEBetaFirewalls) Update(ctx context.Context, key *meta.Key, arg0 *beta.Firewall) error

+ type GCEBetaForwardingRules struct

+ func (g *GCEBetaForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaForwardingRules) Get(ctx context.Context, key *meta.Key) (*beta.ForwardingRule, error)

+ func (g *GCEBetaForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule) error

+ func (g *GCEBetaForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*beta.ForwardingRule, error)

+ func (g *GCEBetaForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *beta.TargetReference) error

+ type GCEBetaGlobalAddresses struct

+ func (g *GCEBetaGlobalAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaGlobalAddresses) Get(ctx context.Context, key *meta.Key) (*beta.Address, error)

+ func (g *GCEBetaGlobalAddresses) Insert(ctx context.Context, key *meta.Key, obj *beta.Address) error

+ func (g *GCEBetaGlobalAddresses) List(ctx context.Context, fl *filter.F) ([]*beta.Address, error)

+ type GCEBetaGlobalForwardingRules struct

+ func (g *GCEBetaGlobalForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaGlobalForwardingRules) Get(ctx context.Context, key *meta.Key) (*beta.ForwardingRule, error)

+ func (g *GCEBetaGlobalForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule) error

+ func (g *GCEBetaGlobalForwardingRules) List(ctx context.Context, fl *filter.F) ([]*beta.ForwardingRule, error)

+ func (g *GCEBetaGlobalForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *beta.TargetReference) error

+ type GCEBetaHealthChecks struct

+ func (g *GCEBetaHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaHealthChecks) Get(ctx context.Context, key *meta.Key) (*beta.HealthCheck, error)

+ func (g *GCEBetaHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *beta.HealthCheck) error

+ func (g *GCEBetaHealthChecks) List(ctx context.Context, fl *filter.F) ([]*beta.HealthCheck, error)

+ func (g *GCEBetaHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *beta.HealthCheck) error

+ type GCEBetaInstances struct

+ func (g *GCEBetaInstances) AttachDisk(ctx context.Context, key *meta.Key, arg0 *beta.AttachedDisk) error

+ func (g *GCEBetaInstances) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaInstances) DetachDisk(ctx context.Context, key *meta.Key, arg0 string) error

+ func (g *GCEBetaInstances) Get(ctx context.Context, key *meta.Key) (*beta.Instance, error)

+ func (g *GCEBetaInstances) Insert(ctx context.Context, key *meta.Key, obj *beta.Instance) error

+ func (g *GCEBetaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*beta.Instance, error)

+ func (g *GCEBetaInstances) UpdateNetworkInterface(ctx context.Context, key *meta.Key, arg0 string, arg1 *beta.NetworkInterface) error

+ type GCEBetaNetworkEndpointGroups struct

+ func (g *GCEBetaNetworkEndpointGroups) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*beta.NetworkEndpointGroup, error)

+ func (g *GCEBetaNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEBetaNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEBetaNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key) (*beta.NetworkEndpointGroup, error)

+ func (g *GCEBetaNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *beta.NetworkEndpointGroup) error

+ func (g *GCEBetaNetworkEndpointGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*beta.NetworkEndpointGroup, error)

+ func (g *GCEBetaNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, ...) ([]*beta.NetworkEndpointWithHealthStatus, error)

+ type GCEBetaNetworks struct

+ func (g *GCEBetaNetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaNetworks) Get(ctx context.Context, key *meta.Key) (*beta.Network, error)

+ func (g *GCEBetaNetworks) Insert(ctx context.Context, key *meta.Key, obj *beta.Network) error

+ func (g *GCEBetaNetworks) List(ctx context.Context, fl *filter.F) ([]*beta.Network, error)

+ type GCEBetaRegionBackendServices struct

+ func (g *GCEBetaRegionBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaRegionBackendServices) Get(ctx context.Context, key *meta.Key) (*beta.BackendService, error)

+ func (g *GCEBetaRegionBackendServices) GetHealth(ctx context.Context, key *meta.Key, arg0 *beta.ResourceGroupReference) (*beta.BackendServiceGroupHealth, error)

+ func (g *GCEBetaRegionBackendServices) Insert(ctx context.Context, key *meta.Key, obj *beta.BackendService) error

+ func (g *GCEBetaRegionBackendServices) List(ctx context.Context, region string, fl *filter.F) ([]*beta.BackendService, error)

+ func (g *GCEBetaRegionBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *beta.BackendService) error

+ type GCEBetaRegionHealthChecks struct

+ func (g *GCEBetaRegionHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaRegionHealthChecks) Get(ctx context.Context, key *meta.Key) (*beta.HealthCheck, error)

+ func (g *GCEBetaRegionHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *beta.HealthCheck) error

+ func (g *GCEBetaRegionHealthChecks) List(ctx context.Context, region string, fl *filter.F) ([]*beta.HealthCheck, error)

+ func (g *GCEBetaRegionHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *beta.HealthCheck) error

+ type GCEBetaRegionSslCertificates struct

+ func (g *GCEBetaRegionSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaRegionSslCertificates) Get(ctx context.Context, key *meta.Key) (*beta.SslCertificate, error)

+ func (g *GCEBetaRegionSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *beta.SslCertificate) error

+ func (g *GCEBetaRegionSslCertificates) List(ctx context.Context, region string, fl *filter.F) ([]*beta.SslCertificate, error)

+ type GCEBetaRegionTargetHttpProxies struct

+ func (g *GCEBetaRegionTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaRegionTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*beta.TargetHttpProxy, error)

+ func (g *GCEBetaRegionTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *beta.TargetHttpProxy) error

+ func (g *GCEBetaRegionTargetHttpProxies) List(ctx context.Context, region string, fl *filter.F) ([]*beta.TargetHttpProxy, error)

+ func (g *GCEBetaRegionTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *beta.UrlMapReference) error

+ type GCEBetaRegionTargetHttpsProxies struct

+ func (g *GCEBetaRegionTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaRegionTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*beta.TargetHttpsProxy, error)

+ func (g *GCEBetaRegionTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *beta.TargetHttpsProxy) error

+ func (g *GCEBetaRegionTargetHttpsProxies) List(ctx context.Context, region string, fl *filter.F) ([]*beta.TargetHttpsProxy, error)

+ func (g *GCEBetaRegionTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEBetaRegionTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *beta.UrlMapReference) error

+ type GCEBetaRegionUrlMaps struct

+ func (g *GCEBetaRegionUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaRegionUrlMaps) Get(ctx context.Context, key *meta.Key) (*beta.UrlMap, error)

+ func (g *GCEBetaRegionUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *beta.UrlMap) error

+ func (g *GCEBetaRegionUrlMaps) List(ctx context.Context, region string, fl *filter.F) ([]*beta.UrlMap, error)

+ func (g *GCEBetaRegionUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *beta.UrlMap) error

+ type GCEBetaSecurityPolicies struct

+ func (g *GCEBetaSecurityPolicies) AddRule(ctx context.Context, key *meta.Key, arg0 *beta.SecurityPolicyRule) error

+ func (g *GCEBetaSecurityPolicies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaSecurityPolicies) Get(ctx context.Context, key *meta.Key) (*beta.SecurityPolicy, error)

+ func (g *GCEBetaSecurityPolicies) GetRule(ctx context.Context, key *meta.Key) (*beta.SecurityPolicyRule, error)

+ func (g *GCEBetaSecurityPolicies) Insert(ctx context.Context, key *meta.Key, obj *beta.SecurityPolicy) error

+ func (g *GCEBetaSecurityPolicies) List(ctx context.Context, fl *filter.F) ([]*beta.SecurityPolicy, error)

+ func (g *GCEBetaSecurityPolicies) Patch(ctx context.Context, key *meta.Key, arg0 *beta.SecurityPolicy) error

+ func (g *GCEBetaSecurityPolicies) PatchRule(ctx context.Context, key *meta.Key, arg0 *beta.SecurityPolicyRule) error

+ func (g *GCEBetaSecurityPolicies) RemoveRule(ctx context.Context, key *meta.Key) error

+ type GCEBetaSslCertificates struct

+ func (g *GCEBetaSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaSslCertificates) Get(ctx context.Context, key *meta.Key) (*beta.SslCertificate, error)

+ func (g *GCEBetaSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *beta.SslCertificate) error

+ func (g *GCEBetaSslCertificates) List(ctx context.Context, fl *filter.F) ([]*beta.SslCertificate, error)

+ type GCEBetaSubnetworks struct

+ func (g *GCEBetaSubnetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaSubnetworks) Get(ctx context.Context, key *meta.Key) (*beta.Subnetwork, error)

+ func (g *GCEBetaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *beta.Subnetwork) error

+ func (g *GCEBetaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Subnetwork, error)

+ type GCEBetaTargetHttpProxies struct

+ func (g *GCEBetaTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*beta.TargetHttpProxy, error)

+ func (g *GCEBetaTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *beta.TargetHttpProxy) error

+ func (g *GCEBetaTargetHttpProxies) List(ctx context.Context, fl *filter.F) ([]*beta.TargetHttpProxy, error)

+ func (g *GCEBetaTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *beta.UrlMapReference) error

+ type GCEBetaTargetHttpsProxies struct

+ func (g *GCEBetaTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*beta.TargetHttpsProxy, error)

+ func (g *GCEBetaTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *beta.TargetHttpsProxy) error

+ func (g *GCEBetaTargetHttpsProxies) List(ctx context.Context, fl *filter.F) ([]*beta.TargetHttpsProxy, error)

+ func (g *GCEBetaTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEBetaTargetHttpsProxies) SetSslPolicy(ctx context.Context, key *meta.Key, arg0 *beta.SslPolicyReference) error

+ func (g *GCEBetaTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *beta.UrlMapReference) error

+ type GCEBetaTargetTcpProxies struct

+ func (g *GCEBetaTargetTcpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaTargetTcpProxies) Get(ctx context.Context, key *meta.Key) (*beta.TargetTcpProxy, error)

+ func (g *GCEBetaTargetTcpProxies) Insert(ctx context.Context, key *meta.Key, obj *beta.TargetTcpProxy) error

+ func (g *GCEBetaTargetTcpProxies) List(ctx context.Context, fl *filter.F) ([]*beta.TargetTcpProxy, error)

+ func (g *GCEBetaTargetTcpProxies) SetBackendService(ctx context.Context, key *meta.Key, ...) error

+ type GCEBetaUrlMaps struct

+ func (g *GCEBetaUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEBetaUrlMaps) Get(ctx context.Context, key *meta.Key) (*beta.UrlMap, error)

+ func (g *GCEBetaUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *beta.UrlMap) error

+ func (g *GCEBetaUrlMaps) List(ctx context.Context, fl *filter.F) ([]*beta.UrlMap, error)

+ func (g *GCEBetaUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *beta.UrlMap) error

+ type GCEDisks struct

+ func (g *GCEDisks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEDisks) Get(ctx context.Context, key *meta.Key) (*ga.Disk, error)

+ func (g *GCEDisks) Insert(ctx context.Context, key *meta.Key, obj *ga.Disk) error

+ func (g *GCEDisks) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Disk, error)

+ func (g *GCEDisks) Resize(ctx context.Context, key *meta.Key, arg0 *ga.DisksResizeRequest) error

+ type GCEFirewalls struct

+ func (g *GCEFirewalls) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEFirewalls) Get(ctx context.Context, key *meta.Key) (*ga.Firewall, error)

+ func (g *GCEFirewalls) Insert(ctx context.Context, key *meta.Key, obj *ga.Firewall) error

+ func (g *GCEFirewalls) List(ctx context.Context, fl *filter.F) ([]*ga.Firewall, error)

+ func (g *GCEFirewalls) Update(ctx context.Context, key *meta.Key, arg0 *ga.Firewall) error

+ type GCEForwardingRules struct

+ func (g *GCEForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEForwardingRules) Get(ctx context.Context, key *meta.Key) (*ga.ForwardingRule, error)

+ func (g *GCEForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *ga.ForwardingRule) error

+ func (g *GCEForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*ga.ForwardingRule, error)

+ func (g *GCEForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *ga.TargetReference) error

+ type GCEGlobalAddresses struct

+ func (g *GCEGlobalAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEGlobalAddresses) Get(ctx context.Context, key *meta.Key) (*ga.Address, error)

+ func (g *GCEGlobalAddresses) Insert(ctx context.Context, key *meta.Key, obj *ga.Address) error

+ func (g *GCEGlobalAddresses) List(ctx context.Context, fl *filter.F) ([]*ga.Address, error)

+ type GCEGlobalForwardingRules struct

+ func (g *GCEGlobalForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEGlobalForwardingRules) Get(ctx context.Context, key *meta.Key) (*ga.ForwardingRule, error)

+ func (g *GCEGlobalForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *ga.ForwardingRule) error

+ func (g *GCEGlobalForwardingRules) List(ctx context.Context, fl *filter.F) ([]*ga.ForwardingRule, error)

+ func (g *GCEGlobalForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *ga.TargetReference) error

+ type GCEHealthChecks struct

+ func (g *GCEHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEHealthChecks) Get(ctx context.Context, key *meta.Key) (*ga.HealthCheck, error)

+ func (g *GCEHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *ga.HealthCheck) error

+ func (g *GCEHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HealthCheck, error)

+ func (g *GCEHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *ga.HealthCheck) error

+ type GCEHttpHealthChecks struct

+ func (g *GCEHttpHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEHttpHealthChecks) Get(ctx context.Context, key *meta.Key) (*ga.HttpHealthCheck, error)

+ func (g *GCEHttpHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *ga.HttpHealthCheck) error

+ func (g *GCEHttpHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpHealthCheck, error)

+ func (g *GCEHttpHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *ga.HttpHealthCheck) error

+ type GCEHttpsHealthChecks struct

+ func (g *GCEHttpsHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEHttpsHealthChecks) Get(ctx context.Context, key *meta.Key) (*ga.HttpsHealthCheck, error)

+ func (g *GCEHttpsHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *ga.HttpsHealthCheck) error

+ func (g *GCEHttpsHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpsHealthCheck, error)

+ func (g *GCEHttpsHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *ga.HttpsHealthCheck) error

+ type GCEInstanceGroups struct

+ func (g *GCEInstanceGroups) AddInstances(ctx context.Context, key *meta.Key, arg0 *ga.InstanceGroupsAddInstancesRequest) error

+ func (g *GCEInstanceGroups) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEInstanceGroups) Get(ctx context.Context, key *meta.Key) (*ga.InstanceGroup, error)

+ func (g *GCEInstanceGroups) Insert(ctx context.Context, key *meta.Key, obj *ga.InstanceGroup) error

+ func (g *GCEInstanceGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroup, error)

+ func (g *GCEInstanceGroups) ListInstances(ctx context.Context, key *meta.Key, ...) ([]*ga.InstanceWithNamedPorts, error)

+ func (g *GCEInstanceGroups) RemoveInstances(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCEInstanceGroups) SetNamedPorts(ctx context.Context, key *meta.Key, ...) error

+ type GCEInstances struct

+ func (g *GCEInstances) AttachDisk(ctx context.Context, key *meta.Key, arg0 *ga.AttachedDisk) error

+ func (g *GCEInstances) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEInstances) DetachDisk(ctx context.Context, key *meta.Key, arg0 string) error

+ func (g *GCEInstances) Get(ctx context.Context, key *meta.Key) (*ga.Instance, error)

+ func (g *GCEInstances) Insert(ctx context.Context, key *meta.Key, obj *ga.Instance) error

+ func (g *GCEInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Instance, error)

+ type GCENetworkEndpointGroups struct

+ func (g *GCENetworkEndpointGroups) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*ga.NetworkEndpointGroup, error)

+ func (g *GCENetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCENetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCENetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCENetworkEndpointGroups) Get(ctx context.Context, key *meta.Key) (*ga.NetworkEndpointGroup, error)

+ func (g *GCENetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *ga.NetworkEndpointGroup) error

+ func (g *GCENetworkEndpointGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.NetworkEndpointGroup, error)

+ func (g *GCENetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, ...) ([]*ga.NetworkEndpointWithHealthStatus, error)

+ type GCENetworks struct

+ func (g *GCENetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCENetworks) Get(ctx context.Context, key *meta.Key) (*ga.Network, error)

+ func (g *GCENetworks) Insert(ctx context.Context, key *meta.Key, obj *ga.Network) error

+ func (g *GCENetworks) List(ctx context.Context, fl *filter.F) ([]*ga.Network, error)

+ type GCEProjects struct

+ func (g *GCEProjects) Get(ctx context.Context, projectID string) (*compute.Project, error)

+ func (g *GCEProjects) SetCommonInstanceMetadata(ctx context.Context, projectID string, m *compute.Metadata) error

+ type GCERegionBackendServices struct

+ func (g *GCERegionBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCERegionBackendServices) Get(ctx context.Context, key *meta.Key) (*ga.BackendService, error)

+ func (g *GCERegionBackendServices) GetHealth(ctx context.Context, key *meta.Key, arg0 *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error)

+ func (g *GCERegionBackendServices) Insert(ctx context.Context, key *meta.Key, obj *ga.BackendService) error

+ func (g *GCERegionBackendServices) List(ctx context.Context, region string, fl *filter.F) ([]*ga.BackendService, error)

+ func (g *GCERegionBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *ga.BackendService) error

+ type GCERegionDisks struct

+ func (g *GCERegionDisks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCERegionDisks) Get(ctx context.Context, key *meta.Key) (*ga.Disk, error)

+ func (g *GCERegionDisks) Insert(ctx context.Context, key *meta.Key, obj *ga.Disk) error

+ func (g *GCERegionDisks) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Disk, error)

+ func (g *GCERegionDisks) Resize(ctx context.Context, key *meta.Key, arg0 *ga.RegionDisksResizeRequest) error

+ type GCERegionHealthChecks struct

+ func (g *GCERegionHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCERegionHealthChecks) Get(ctx context.Context, key *meta.Key) (*ga.HealthCheck, error)

+ func (g *GCERegionHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *ga.HealthCheck) error

+ func (g *GCERegionHealthChecks) List(ctx context.Context, region string, fl *filter.F) ([]*ga.HealthCheck, error)

+ func (g *GCERegionHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *ga.HealthCheck) error

+ type GCERegionSslCertificates struct

+ func (g *GCERegionSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCERegionSslCertificates) Get(ctx context.Context, key *meta.Key) (*ga.SslCertificate, error)

+ func (g *GCERegionSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *ga.SslCertificate) error

+ func (g *GCERegionSslCertificates) List(ctx context.Context, region string, fl *filter.F) ([]*ga.SslCertificate, error)

+ type GCERegionTargetHttpProxies struct

+ func (g *GCERegionTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCERegionTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*ga.TargetHttpProxy, error)

+ func (g *GCERegionTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetHttpProxy) error

+ func (g *GCERegionTargetHttpProxies) List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetHttpProxy, error)

+ func (g *GCERegionTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *ga.UrlMapReference) error

+ type GCERegionTargetHttpsProxies struct

+ func (g *GCERegionTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCERegionTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*ga.TargetHttpsProxy, error)

+ func (g *GCERegionTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetHttpsProxy) error

+ func (g *GCERegionTargetHttpsProxies) List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetHttpsProxy, error)

+ func (g *GCERegionTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCERegionTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *ga.UrlMapReference) error

+ type GCERegionUrlMaps struct

+ func (g *GCERegionUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCERegionUrlMaps) Get(ctx context.Context, key *meta.Key) (*ga.UrlMap, error)

+ func (g *GCERegionUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *ga.UrlMap) error

+ func (g *GCERegionUrlMaps) List(ctx context.Context, region string, fl *filter.F) ([]*ga.UrlMap, error)

+ func (g *GCERegionUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *ga.UrlMap) error

+ type GCERegions struct

+ func (g *GCERegions) Get(ctx context.Context, key *meta.Key) (*ga.Region, error)

+ func (g *GCERegions) List(ctx context.Context, fl *filter.F) ([]*ga.Region, error)

+ type GCERoutes struct

+ func (g *GCERoutes) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCERoutes) Get(ctx context.Context, key *meta.Key) (*ga.Route, error)

+ func (g *GCERoutes) Insert(ctx context.Context, key *meta.Key, obj *ga.Route) error

+ func (g *GCERoutes) List(ctx context.Context, fl *filter.F) ([]*ga.Route, error)

+ type GCESslCertificates struct

+ func (g *GCESslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCESslCertificates) Get(ctx context.Context, key *meta.Key) (*ga.SslCertificate, error)

+ func (g *GCESslCertificates) Insert(ctx context.Context, key *meta.Key, obj *ga.SslCertificate) error

+ func (g *GCESslCertificates) List(ctx context.Context, fl *filter.F) ([]*ga.SslCertificate, error)

+ type GCESslPolicies struct

+ func (g *GCESslPolicies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCESslPolicies) Get(ctx context.Context, key *meta.Key) (*ga.SslPolicy, error)

+ func (g *GCESslPolicies) Insert(ctx context.Context, key *meta.Key, obj *ga.SslPolicy) error

+ type GCESubnetworks struct

+ func (g *GCESubnetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCESubnetworks) Get(ctx context.Context, key *meta.Key) (*ga.Subnetwork, error)

+ func (g *GCESubnetworks) Insert(ctx context.Context, key *meta.Key, obj *ga.Subnetwork) error

+ func (g *GCESubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Subnetwork, error)

+ type GCETargetHttpProxies struct

+ func (g *GCETargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCETargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*ga.TargetHttpProxy, error)

+ func (g *GCETargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetHttpProxy) error

+ func (g *GCETargetHttpProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpProxy, error)

+ func (g *GCETargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *ga.UrlMapReference) error

+ type GCETargetHttpsProxies struct

+ func (g *GCETargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCETargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*ga.TargetHttpsProxy, error)

+ func (g *GCETargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetHttpsProxy) error

+ func (g *GCETargetHttpsProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpsProxy, error)

+ func (g *GCETargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (g *GCETargetHttpsProxies) SetSslPolicy(ctx context.Context, key *meta.Key, arg0 *ga.SslPolicyReference) error

+ func (g *GCETargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *ga.UrlMapReference) error

+ type GCETargetPools struct

+ func (g *GCETargetPools) AddInstance(ctx context.Context, key *meta.Key, arg0 *ga.TargetPoolsAddInstanceRequest) error

+ func (g *GCETargetPools) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCETargetPools) Get(ctx context.Context, key *meta.Key) (*ga.TargetPool, error)

+ func (g *GCETargetPools) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetPool) error

+ func (g *GCETargetPools) List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetPool, error)

+ func (g *GCETargetPools) RemoveInstance(ctx context.Context, key *meta.Key, arg0 *ga.TargetPoolsRemoveInstanceRequest) error

+ type GCEUrlMaps struct

+ func (g *GCEUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (g *GCEUrlMaps) Get(ctx context.Context, key *meta.Key) (*ga.UrlMap, error)

+ func (g *GCEUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *ga.UrlMap) error

+ func (g *GCEUrlMaps) List(ctx context.Context, fl *filter.F) ([]*ga.UrlMap, error)

+ func (g *GCEUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *ga.UrlMap) error

+ type GCEZones struct

+ func (g *GCEZones) Get(ctx context.Context, key *meta.Key) (*ga.Zone, error)

+ func (g *GCEZones) List(ctx context.Context, fl *filter.F) ([]*ga.Zone, error)

+ type GlobalAddresses interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Address, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Address) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.Address, error)

+ type GlobalForwardingRules interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.ForwardingRule, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.ForwardingRule) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.ForwardingRule, error)

+ SetTarget func(context.Context, *meta.Key, *ga.TargetReference) error

+ type HealthChecks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.HealthCheck, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.HealthCheck) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.HealthCheck, error)

+ Update func(context.Context, *meta.Key, *ga.HealthCheck) error

+ type HttpHealthChecks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.HttpHealthCheck, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.HttpHealthCheck) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.HttpHealthCheck, error)

+ Update func(context.Context, *meta.Key, *ga.HttpHealthCheck) error

+ type HttpsHealthChecks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.HttpsHealthCheck, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.HttpsHealthCheck) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.HttpsHealthCheck, error)

+ Update func(context.Context, *meta.Key, *ga.HttpsHealthCheck) error

+ type InstanceGroups interface

+ AddInstances func(context.Context, *meta.Key, *ga.InstanceGroupsAddInstancesRequest) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.InstanceGroup, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.InstanceGroup) error

+ List func(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroup, error)

+ ListInstances func(context.Context, *meta.Key, *ga.InstanceGroupsListInstancesRequest, *filter.F) ([]*ga.InstanceWithNamedPorts, error)

+ RemoveInstances func(context.Context, *meta.Key, *ga.InstanceGroupsRemoveInstancesRequest) error

+ SetNamedPorts func(context.Context, *meta.Key, *ga.InstanceGroupsSetNamedPortsRequest) error

+ type Instances interface

+ AttachDisk func(context.Context, *meta.Key, *ga.AttachedDisk) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ DetachDisk func(context.Context, *meta.Key, string) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Instance, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Instance) error

+ List func(ctx context.Context, zone string, fl *filter.F) ([]*ga.Instance, error)

+ type LbScheme string

+ type MinimumRateLimiter struct

+ Minimum time.Duration

+ RateLimiter RateLimiter

+ func (m *MinimumRateLimiter) Accept(ctx context.Context, key *RateLimitKey) error

+ type MockAddresses struct

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockAddresses) (bool, map[string][]*ga.Address, error)

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAddresses) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAddresses) (bool, *ga.Address, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Address, m *MockAddresses) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAddresses) (bool, []*ga.Address, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockAddressesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAddresses(pr ProjectRouter, objs map[meta.Key]*MockAddressesObj) *MockAddresses

+ func (m *MockAddresses) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*ga.Address, error)

+ func (m *MockAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAddresses) Get(ctx context.Context, key *meta.Key) (*ga.Address, error)

+ func (m *MockAddresses) Insert(ctx context.Context, key *meta.Key, obj *ga.Address) error

+ func (m *MockAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Address, error)

+ func (m *MockAddresses) Obj(o *ga.Address) *MockAddressesObj

+ type MockAddressesObj struct

+ Obj interface{}

+ func (m *MockAddressesObj) ToAlpha() *alpha.Address

+ func (m *MockAddressesObj) ToBeta() *beta.Address

+ func (m *MockAddressesObj) ToGA() *ga.Address

+ type MockAlphaAddresses struct

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockAlphaAddresses) (bool, map[string][]*alpha.Address, error)

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaAddresses) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaAddresses) (bool, *alpha.Address, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.Address, m *MockAlphaAddresses) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaAddresses) (bool, []*alpha.Address, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockAddressesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAlphaAddresses(pr ProjectRouter, objs map[meta.Key]*MockAddressesObj) *MockAlphaAddresses

+ func (m *MockAlphaAddresses) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.Address, error)

+ func (m *MockAlphaAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaAddresses) Get(ctx context.Context, key *meta.Key) (*alpha.Address, error)

+ func (m *MockAlphaAddresses) Insert(ctx context.Context, key *meta.Key, obj *alpha.Address) error

+ func (m *MockAlphaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Address, error)

+ func (m *MockAlphaAddresses) Obj(o *alpha.Address) *MockAddressesObj

+ type MockAlphaBackendServices struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaBackendServices) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaBackendServices) (bool, *alpha.BackendService, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.BackendService, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaBackendServices) (bool, []*alpha.BackendService, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockBackendServicesObj

+ ProjectRouter ProjectRouter

+ SetSecurityPolicyHook func(context.Context, *meta.Key, *alpha.SecurityPolicyReference, ...) error

+ UpdateHook func(context.Context, *meta.Key, *alpha.BackendService, *MockAlphaBackendServices) error

+ X interface{}

+ func NewMockAlphaBackendServices(pr ProjectRouter, objs map[meta.Key]*MockBackendServicesObj) *MockAlphaBackendServices

+ func (m *MockAlphaBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaBackendServices) Get(ctx context.Context, key *meta.Key) (*alpha.BackendService, error)

+ func (m *MockAlphaBackendServices) Insert(ctx context.Context, key *meta.Key, obj *alpha.BackendService) error

+ func (m *MockAlphaBackendServices) List(ctx context.Context, fl *filter.F) ([]*alpha.BackendService, error)

+ func (m *MockAlphaBackendServices) Obj(o *alpha.BackendService) *MockBackendServicesObj

+ func (m *MockAlphaBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *alpha.SecurityPolicyReference) error

+ func (m *MockAlphaBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *alpha.BackendService) error

+ type MockAlphaFirewalls struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaFirewalls) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaFirewalls) (bool, *alpha.Firewall, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.Firewall, m *MockAlphaFirewalls) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaFirewalls) (bool, []*alpha.Firewall, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockFirewallsObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *alpha.Firewall, *MockAlphaFirewalls) error

+ X interface{}

+ func NewMockAlphaFirewalls(pr ProjectRouter, objs map[meta.Key]*MockFirewallsObj) *MockAlphaFirewalls

+ func (m *MockAlphaFirewalls) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaFirewalls) Get(ctx context.Context, key *meta.Key) (*alpha.Firewall, error)

+ func (m *MockAlphaFirewalls) Insert(ctx context.Context, key *meta.Key, obj *alpha.Firewall) error

+ func (m *MockAlphaFirewalls) List(ctx context.Context, fl *filter.F) ([]*alpha.Firewall, error)

+ func (m *MockAlphaFirewalls) Obj(o *alpha.Firewall) *MockFirewallsObj

+ func (m *MockAlphaFirewalls) Update(ctx context.Context, key *meta.Key, arg0 *alpha.Firewall) error

+ type MockAlphaForwardingRules struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaForwardingRules) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaForwardingRules) (bool, *alpha.ForwardingRule, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.ForwardingRule, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaForwardingRules) (bool, []*alpha.ForwardingRule, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockForwardingRulesObj

+ ProjectRouter ProjectRouter

+ SetTargetHook func(context.Context, *meta.Key, *alpha.TargetReference, *MockAlphaForwardingRules) error

+ X interface{}

+ func NewMockAlphaForwardingRules(pr ProjectRouter, objs map[meta.Key]*MockForwardingRulesObj) *MockAlphaForwardingRules

+ func (m *MockAlphaForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaForwardingRules) Get(ctx context.Context, key *meta.Key) (*alpha.ForwardingRule, error)

+ func (m *MockAlphaForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *alpha.ForwardingRule) error

+ func (m *MockAlphaForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.ForwardingRule, error)

+ func (m *MockAlphaForwardingRules) Obj(o *alpha.ForwardingRule) *MockForwardingRulesObj

+ func (m *MockAlphaForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *alpha.TargetReference) error

+ type MockAlphaGlobalAddresses struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaGlobalAddresses) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaGlobalAddresses) (bool, *alpha.Address, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.Address, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaGlobalAddresses) (bool, []*alpha.Address, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockGlobalAddressesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAlphaGlobalAddresses(pr ProjectRouter, objs map[meta.Key]*MockGlobalAddressesObj) *MockAlphaGlobalAddresses

+ func (m *MockAlphaGlobalAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaGlobalAddresses) Get(ctx context.Context, key *meta.Key) (*alpha.Address, error)

+ func (m *MockAlphaGlobalAddresses) Insert(ctx context.Context, key *meta.Key, obj *alpha.Address) error

+ func (m *MockAlphaGlobalAddresses) List(ctx context.Context, fl *filter.F) ([]*alpha.Address, error)

+ func (m *MockAlphaGlobalAddresses) Obj(o *alpha.Address) *MockGlobalAddressesObj

+ type MockAlphaGlobalForwardingRules struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaGlobalForwardingRules) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaGlobalForwardingRules) (bool, *alpha.ForwardingRule, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.ForwardingRule, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaGlobalForwardingRules) (bool, []*alpha.ForwardingRule, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockGlobalForwardingRulesObj

+ ProjectRouter ProjectRouter

+ SetTargetHook func(context.Context, *meta.Key, *alpha.TargetReference, ...) error

+ X interface{}

+ func NewMockAlphaGlobalForwardingRules(pr ProjectRouter, objs map[meta.Key]*MockGlobalForwardingRulesObj) *MockAlphaGlobalForwardingRules

+ func (m *MockAlphaGlobalForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaGlobalForwardingRules) Get(ctx context.Context, key *meta.Key) (*alpha.ForwardingRule, error)

+ func (m *MockAlphaGlobalForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *alpha.ForwardingRule) error

+ func (m *MockAlphaGlobalForwardingRules) List(ctx context.Context, fl *filter.F) ([]*alpha.ForwardingRule, error)

+ func (m *MockAlphaGlobalForwardingRules) Obj(o *alpha.ForwardingRule) *MockGlobalForwardingRulesObj

+ func (m *MockAlphaGlobalForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *alpha.TargetReference) error

+ type MockAlphaHealthChecks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaHealthChecks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaHealthChecks) (bool, *alpha.HealthCheck, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.HealthCheck, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaHealthChecks) (bool, []*alpha.HealthCheck, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockHealthChecksObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *alpha.HealthCheck, *MockAlphaHealthChecks) error

+ X interface{}

+ func NewMockAlphaHealthChecks(pr ProjectRouter, objs map[meta.Key]*MockHealthChecksObj) *MockAlphaHealthChecks

+ func (m *MockAlphaHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaHealthChecks) Get(ctx context.Context, key *meta.Key) (*alpha.HealthCheck, error)

+ func (m *MockAlphaHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *alpha.HealthCheck) error

+ func (m *MockAlphaHealthChecks) List(ctx context.Context, fl *filter.F) ([]*alpha.HealthCheck, error)

+ func (m *MockAlphaHealthChecks) Obj(o *alpha.HealthCheck) *MockHealthChecksObj

+ func (m *MockAlphaHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *alpha.HealthCheck) error

+ type MockAlphaInstances struct

+ AttachDiskHook func(context.Context, *meta.Key, *alpha.AttachedDisk, *MockAlphaInstances) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaInstances) (bool, error)

+ DetachDiskHook func(context.Context, *meta.Key, string, *MockAlphaInstances) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaInstances) (bool, *alpha.Instance, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.Instance, m *MockAlphaInstances) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, zone string, fl *filter.F, m *MockAlphaInstances) (bool, []*alpha.Instance, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockInstancesObj

+ ProjectRouter ProjectRouter

+ UpdateNetworkInterfaceHook func(context.Context, *meta.Key, string, *alpha.NetworkInterface, ...) error

+ X interface{}

+ func NewMockAlphaInstances(pr ProjectRouter, objs map[meta.Key]*MockInstancesObj) *MockAlphaInstances

+ func (m *MockAlphaInstances) AttachDisk(ctx context.Context, key *meta.Key, arg0 *alpha.AttachedDisk) error

+ func (m *MockAlphaInstances) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaInstances) DetachDisk(ctx context.Context, key *meta.Key, arg0 string) error

+ func (m *MockAlphaInstances) Get(ctx context.Context, key *meta.Key) (*alpha.Instance, error)

+ func (m *MockAlphaInstances) Insert(ctx context.Context, key *meta.Key, obj *alpha.Instance) error

+ func (m *MockAlphaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.Instance, error)

+ func (m *MockAlphaInstances) Obj(o *alpha.Instance) *MockInstancesObj

+ func (m *MockAlphaInstances) UpdateNetworkInterface(ctx context.Context, key *meta.Key, arg0 string, arg1 *alpha.NetworkInterface) error

+ type MockAlphaNetworkEndpointGroups struct

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockAlphaNetworkEndpointGroups) (bool, map[string][]*alpha.NetworkEndpointGroup, error)

+ AttachNetworkEndpointsHook func(context.Context, *meta.Key, *alpha.NetworkEndpointGroupsAttachEndpointsRequest, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaNetworkEndpointGroups) (bool, error)

+ DetachNetworkEndpointsHook func(context.Context, *meta.Key, *alpha.NetworkEndpointGroupsDetachEndpointsRequest, ...) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaNetworkEndpointGroups) (bool, *alpha.NetworkEndpointGroup, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.NetworkEndpointGroup, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, zone string, fl *filter.F, ...) (bool, []*alpha.NetworkEndpointGroup, error)

+ ListNetworkEndpointsHook func(context.Context, *meta.Key, *alpha.NetworkEndpointGroupsListEndpointsRequest, ...) ([]*alpha.NetworkEndpointWithHealthStatus, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockNetworkEndpointGroupsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAlphaNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockNetworkEndpointGroupsObj) *MockAlphaNetworkEndpointGroups

+ func (m *MockAlphaNetworkEndpointGroups) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*alpha.NetworkEndpointGroup, error)

+ func (m *MockAlphaNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockAlphaNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockAlphaNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key) (*alpha.NetworkEndpointGroup, error)

+ func (m *MockAlphaNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *alpha.NetworkEndpointGroup) error

+ func (m *MockAlphaNetworkEndpointGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*alpha.NetworkEndpointGroup, error)

+ func (m *MockAlphaNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, ...) ([]*alpha.NetworkEndpointWithHealthStatus, error)

+ func (m *MockAlphaNetworkEndpointGroups) Obj(o *alpha.NetworkEndpointGroup) *MockNetworkEndpointGroupsObj

+ type MockAlphaNetworks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaNetworks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaNetworks) (bool, *alpha.Network, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.Network, m *MockAlphaNetworks) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaNetworks) (bool, []*alpha.Network, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockNetworksObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAlphaNetworks(pr ProjectRouter, objs map[meta.Key]*MockNetworksObj) *MockAlphaNetworks

+ func (m *MockAlphaNetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaNetworks) Get(ctx context.Context, key *meta.Key) (*alpha.Network, error)

+ func (m *MockAlphaNetworks) Insert(ctx context.Context, key *meta.Key, obj *alpha.Network) error

+ func (m *MockAlphaNetworks) List(ctx context.Context, fl *filter.F) ([]*alpha.Network, error)

+ func (m *MockAlphaNetworks) Obj(o *alpha.Network) *MockNetworksObj

+ type MockAlphaRegionBackendServices struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionBackendServices) (bool, error)

+ GetError map[meta.Key]error

+ GetHealthHook func(context.Context, *meta.Key, *alpha.ResourceGroupReference, ...) (*alpha.BackendServiceGroupHealth, error)

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionBackendServices) (bool, *alpha.BackendService, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.BackendService, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*alpha.BackendService, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionBackendServicesObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *alpha.BackendService, ...) error

+ X interface{}

+ func NewMockAlphaRegionBackendServices(pr ProjectRouter, objs map[meta.Key]*MockRegionBackendServicesObj) *MockAlphaRegionBackendServices

+ func (m *MockAlphaRegionBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRegionBackendServices) Get(ctx context.Context, key *meta.Key) (*alpha.BackendService, error)

+ func (m *MockAlphaRegionBackendServices) GetHealth(ctx context.Context, key *meta.Key, arg0 *alpha.ResourceGroupReference) (*alpha.BackendServiceGroupHealth, error)

+ func (m *MockAlphaRegionBackendServices) Insert(ctx context.Context, key *meta.Key, obj *alpha.BackendService) error

+ func (m *MockAlphaRegionBackendServices) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.BackendService, error)

+ func (m *MockAlphaRegionBackendServices) Obj(o *alpha.BackendService) *MockRegionBackendServicesObj

+ func (m *MockAlphaRegionBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *alpha.BackendService) error

+ type MockAlphaRegionHealthChecks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionHealthChecks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionHealthChecks) (bool, *alpha.HealthCheck, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.HealthCheck, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*alpha.HealthCheck, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionHealthChecksObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *alpha.HealthCheck, *MockAlphaRegionHealthChecks) error

+ X interface{}

+ func NewMockAlphaRegionHealthChecks(pr ProjectRouter, objs map[meta.Key]*MockRegionHealthChecksObj) *MockAlphaRegionHealthChecks

+ func (m *MockAlphaRegionHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRegionHealthChecks) Get(ctx context.Context, key *meta.Key) (*alpha.HealthCheck, error)

+ func (m *MockAlphaRegionHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *alpha.HealthCheck) error

+ func (m *MockAlphaRegionHealthChecks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.HealthCheck, error)

+ func (m *MockAlphaRegionHealthChecks) Obj(o *alpha.HealthCheck) *MockRegionHealthChecksObj

+ func (m *MockAlphaRegionHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *alpha.HealthCheck) error

+ type MockAlphaRegionSslCertificates struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionSslCertificates) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionSslCertificates) (bool, *alpha.SslCertificate, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*alpha.SslCertificate, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionSslCertificatesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAlphaRegionSslCertificates(pr ProjectRouter, objs map[meta.Key]*MockRegionSslCertificatesObj) *MockAlphaRegionSslCertificates

+ func (m *MockAlphaRegionSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRegionSslCertificates) Get(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error)

+ func (m *MockAlphaRegionSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error

+ func (m *MockAlphaRegionSslCertificates) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.SslCertificate, error)

+ func (m *MockAlphaRegionSslCertificates) Obj(o *alpha.SslCertificate) *MockRegionSslCertificatesObj

+ type MockAlphaRegionTargetHttpProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionTargetHttpProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionTargetHttpProxies) (bool, *alpha.TargetHttpProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*alpha.TargetHttpProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionTargetHttpProxiesObj

+ ProjectRouter ProjectRouter

+ SetUrlMapHook func(context.Context, *meta.Key, *alpha.UrlMapReference, ...) error

+ X interface{}

+ func NewMockAlphaRegionTargetHttpProxies(pr ProjectRouter, objs map[meta.Key]*MockRegionTargetHttpProxiesObj) *MockAlphaRegionTargetHttpProxies

+ func (m *MockAlphaRegionTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRegionTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*alpha.TargetHttpProxy, error)

+ func (m *MockAlphaRegionTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpProxy) error

+ func (m *MockAlphaRegionTargetHttpProxies) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.TargetHttpProxy, error)

+ func (m *MockAlphaRegionTargetHttpProxies) Obj(o *alpha.TargetHttpProxy) *MockRegionTargetHttpProxiesObj

+ func (m *MockAlphaRegionTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMapReference) error

+ type MockAlphaRegionTargetHttpsProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionTargetHttpsProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionTargetHttpsProxies) (bool, *alpha.TargetHttpsProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpsProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*alpha.TargetHttpsProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionTargetHttpsProxiesObj

+ ProjectRouter ProjectRouter

+ SetSslCertificatesHook func(context.Context, *meta.Key, ...) error

+ SetUrlMapHook func(context.Context, *meta.Key, *alpha.UrlMapReference, ...) error

+ X interface{}

+ func NewMockAlphaRegionTargetHttpsProxies(pr ProjectRouter, objs map[meta.Key]*MockRegionTargetHttpsProxiesObj) *MockAlphaRegionTargetHttpsProxies

+ func (m *MockAlphaRegionTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRegionTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*alpha.TargetHttpsProxy, error)

+ func (m *MockAlphaRegionTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpsProxy) error

+ func (m *MockAlphaRegionTargetHttpsProxies) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.TargetHttpsProxy, error)

+ func (m *MockAlphaRegionTargetHttpsProxies) Obj(o *alpha.TargetHttpsProxy) *MockRegionTargetHttpsProxiesObj

+ func (m *MockAlphaRegionTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockAlphaRegionTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMapReference) error

+ type MockAlphaRegionUrlMaps struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionUrlMaps) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaRegionUrlMaps) (bool, *alpha.UrlMap, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.UrlMap, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaRegionUrlMaps) (bool, []*alpha.UrlMap, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionUrlMapsObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *alpha.UrlMap, *MockAlphaRegionUrlMaps) error

+ X interface{}

+ func NewMockAlphaRegionUrlMaps(pr ProjectRouter, objs map[meta.Key]*MockRegionUrlMapsObj) *MockAlphaRegionUrlMaps

+ func (m *MockAlphaRegionUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaRegionUrlMaps) Get(ctx context.Context, key *meta.Key) (*alpha.UrlMap, error)

+ func (m *MockAlphaRegionUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *alpha.UrlMap) error

+ func (m *MockAlphaRegionUrlMaps) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.UrlMap, error)

+ func (m *MockAlphaRegionUrlMaps) Obj(o *alpha.UrlMap) *MockRegionUrlMapsObj

+ func (m *MockAlphaRegionUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMap) error

+ type MockAlphaServiceAttachments struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaServiceAttachments) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaServiceAttachments) (bool, *alpha.ServiceAttachment, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.ServiceAttachment, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*alpha.ServiceAttachment, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockServiceAttachmentsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAlphaServiceAttachments(pr ProjectRouter, objs map[meta.Key]*MockServiceAttachmentsObj) *MockAlphaServiceAttachments

+ func (m *MockAlphaServiceAttachments) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaServiceAttachments) Get(ctx context.Context, key *meta.Key) (*alpha.ServiceAttachment, error)

+ func (m *MockAlphaServiceAttachments) Insert(ctx context.Context, key *meta.Key, obj *alpha.ServiceAttachment) error

+ func (m *MockAlphaServiceAttachments) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.ServiceAttachment, error)

+ func (m *MockAlphaServiceAttachments) Obj(o *alpha.ServiceAttachment) *MockServiceAttachmentsObj

+ type MockAlphaSslCertificates struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaSslCertificates) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaSslCertificates) (bool, *alpha.SslCertificate, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaSslCertificates) (bool, []*alpha.SslCertificate, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockSslCertificatesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAlphaSslCertificates(pr ProjectRouter, objs map[meta.Key]*MockSslCertificatesObj) *MockAlphaSslCertificates

+ func (m *MockAlphaSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaSslCertificates) Get(ctx context.Context, key *meta.Key) (*alpha.SslCertificate, error)

+ func (m *MockAlphaSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *alpha.SslCertificate) error

+ func (m *MockAlphaSslCertificates) List(ctx context.Context, fl *filter.F) ([]*alpha.SslCertificate, error)

+ func (m *MockAlphaSslCertificates) Obj(o *alpha.SslCertificate) *MockSslCertificatesObj

+ type MockAlphaSubnetworks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaSubnetworks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaSubnetworks) (bool, *alpha.Subnetwork, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockAlphaSubnetworks) (bool, []*alpha.Subnetwork, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockSubnetworksObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockAlphaSubnetworks(pr ProjectRouter, objs map[meta.Key]*MockSubnetworksObj) *MockAlphaSubnetworks

+ func (m *MockAlphaSubnetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaSubnetworks) Get(ctx context.Context, key *meta.Key) (*alpha.Subnetwork, error)

+ func (m *MockAlphaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *alpha.Subnetwork) error

+ func (m *MockAlphaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*alpha.Subnetwork, error)

+ func (m *MockAlphaSubnetworks) Obj(o *alpha.Subnetwork) *MockSubnetworksObj

+ type MockAlphaTargetHttpProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaTargetHttpProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaTargetHttpProxies) (bool, *alpha.TargetHttpProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaTargetHttpProxies) (bool, []*alpha.TargetHttpProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTargetHttpProxiesObj

+ ProjectRouter ProjectRouter

+ SetUrlMapHook func(context.Context, *meta.Key, *alpha.UrlMapReference, ...) error

+ X interface{}

+ func NewMockAlphaTargetHttpProxies(pr ProjectRouter, objs map[meta.Key]*MockTargetHttpProxiesObj) *MockAlphaTargetHttpProxies

+ func (m *MockAlphaTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*alpha.TargetHttpProxy, error)

+ func (m *MockAlphaTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpProxy) error

+ func (m *MockAlphaTargetHttpProxies) List(ctx context.Context, fl *filter.F) ([]*alpha.TargetHttpProxy, error)

+ func (m *MockAlphaTargetHttpProxies) Obj(o *alpha.TargetHttpProxy) *MockTargetHttpProxiesObj

+ func (m *MockAlphaTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMapReference) error

+ type MockAlphaTargetHttpsProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaTargetHttpsProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaTargetHttpsProxies) (bool, *alpha.TargetHttpsProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpsProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaTargetHttpsProxies) (bool, []*alpha.TargetHttpsProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTargetHttpsProxiesObj

+ ProjectRouter ProjectRouter

+ SetSslCertificatesHook func(context.Context, *meta.Key, *alpha.TargetHttpsProxiesSetSslCertificatesRequest, ...) error

+ SetSslPolicyHook func(context.Context, *meta.Key, *alpha.SslPolicyReference, ...) error

+ SetUrlMapHook func(context.Context, *meta.Key, *alpha.UrlMapReference, ...) error

+ X interface{}

+ func NewMockAlphaTargetHttpsProxies(pr ProjectRouter, objs map[meta.Key]*MockTargetHttpsProxiesObj) *MockAlphaTargetHttpsProxies

+ func (m *MockAlphaTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*alpha.TargetHttpsProxy, error)

+ func (m *MockAlphaTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *alpha.TargetHttpsProxy) error

+ func (m *MockAlphaTargetHttpsProxies) List(ctx context.Context, fl *filter.F) ([]*alpha.TargetHttpsProxy, error)

+ func (m *MockAlphaTargetHttpsProxies) Obj(o *alpha.TargetHttpsProxy) *MockTargetHttpsProxiesObj

+ func (m *MockAlphaTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockAlphaTargetHttpsProxies) SetSslPolicy(ctx context.Context, key *meta.Key, arg0 *alpha.SslPolicyReference) error

+ func (m *MockAlphaTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMapReference) error

+ type MockAlphaTargetTcpProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaTargetTcpProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaTargetTcpProxies) (bool, *alpha.TargetTcpProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.TargetTcpProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaTargetTcpProxies) (bool, []*alpha.TargetTcpProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTargetTcpProxiesObj

+ ProjectRouter ProjectRouter

+ SetBackendServiceHook func(context.Context, *meta.Key, *alpha.TargetTcpProxiesSetBackendServiceRequest, ...) error

+ X interface{}

+ func NewMockAlphaTargetTcpProxies(pr ProjectRouter, objs map[meta.Key]*MockTargetTcpProxiesObj) *MockAlphaTargetTcpProxies

+ func (m *MockAlphaTargetTcpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaTargetTcpProxies) Get(ctx context.Context, key *meta.Key) (*alpha.TargetTcpProxy, error)

+ func (m *MockAlphaTargetTcpProxies) Insert(ctx context.Context, key *meta.Key, obj *alpha.TargetTcpProxy) error

+ func (m *MockAlphaTargetTcpProxies) List(ctx context.Context, fl *filter.F) ([]*alpha.TargetTcpProxy, error)

+ func (m *MockAlphaTargetTcpProxies) Obj(o *alpha.TargetTcpProxy) *MockTargetTcpProxiesObj

+ func (m *MockAlphaTargetTcpProxies) SetBackendService(ctx context.Context, key *meta.Key, ...) error

+ type MockAlphaUrlMaps struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockAlphaUrlMaps) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockAlphaUrlMaps) (bool, *alpha.UrlMap, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *alpha.UrlMap, m *MockAlphaUrlMaps) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockAlphaUrlMaps) (bool, []*alpha.UrlMap, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockUrlMapsObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *alpha.UrlMap, *MockAlphaUrlMaps) error

+ X interface{}

+ func NewMockAlphaUrlMaps(pr ProjectRouter, objs map[meta.Key]*MockUrlMapsObj) *MockAlphaUrlMaps

+ func (m *MockAlphaUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockAlphaUrlMaps) Get(ctx context.Context, key *meta.Key) (*alpha.UrlMap, error)

+ func (m *MockAlphaUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *alpha.UrlMap) error

+ func (m *MockAlphaUrlMaps) List(ctx context.Context, fl *filter.F) ([]*alpha.UrlMap, error)

+ func (m *MockAlphaUrlMaps) Obj(o *alpha.UrlMap) *MockUrlMapsObj

+ func (m *MockAlphaUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *alpha.UrlMap) error

+ type MockBackendServices struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBackendServices) (bool, error)

+ GetError map[meta.Key]error

+ GetHealthHook func(context.Context, *meta.Key, *ga.ResourceGroupReference, *MockBackendServices) (*ga.BackendServiceGroupHealth, error)

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBackendServices) (bool, *ga.BackendService, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.BackendService, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBackendServices) (bool, []*ga.BackendService, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockBackendServicesObj

+ PatchHook func(context.Context, *meta.Key, *ga.BackendService, *MockBackendServices) error

+ ProjectRouter ProjectRouter

+ SetSecurityPolicyHook func(context.Context, *meta.Key, *ga.SecurityPolicyReference, *MockBackendServices) error

+ UpdateHook func(context.Context, *meta.Key, *ga.BackendService, *MockBackendServices) error

+ X interface{}

+ func NewMockBackendServices(pr ProjectRouter, objs map[meta.Key]*MockBackendServicesObj) *MockBackendServices

+ func (m *MockBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBackendServices) Get(ctx context.Context, key *meta.Key) (*ga.BackendService, error)

+ func (m *MockBackendServices) GetHealth(ctx context.Context, key *meta.Key, arg0 *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error)

+ func (m *MockBackendServices) Insert(ctx context.Context, key *meta.Key, obj *ga.BackendService) error

+ func (m *MockBackendServices) List(ctx context.Context, fl *filter.F) ([]*ga.BackendService, error)

+ func (m *MockBackendServices) Obj(o *ga.BackendService) *MockBackendServicesObj

+ func (m *MockBackendServices) Patch(ctx context.Context, key *meta.Key, arg0 *ga.BackendService) error

+ func (m *MockBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *ga.SecurityPolicyReference) error

+ func (m *MockBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *ga.BackendService) error

+ type MockBackendServicesObj struct

+ Obj interface{}

+ func (m *MockBackendServicesObj) ToAlpha() *alpha.BackendService

+ func (m *MockBackendServicesObj) ToBeta() *beta.BackendService

+ func (m *MockBackendServicesObj) ToGA() *ga.BackendService

+ type MockBetaAddresses struct

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockBetaAddresses) (bool, map[string][]*beta.Address, error)

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaAddresses) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaAddresses) (bool, *beta.Address, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.Address, m *MockBetaAddresses) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockBetaAddresses) (bool, []*beta.Address, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockAddressesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaAddresses(pr ProjectRouter, objs map[meta.Key]*MockAddressesObj) *MockBetaAddresses

+ func (m *MockBetaAddresses) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*beta.Address, error)

+ func (m *MockBetaAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaAddresses) Get(ctx context.Context, key *meta.Key) (*beta.Address, error)

+ func (m *MockBetaAddresses) Insert(ctx context.Context, key *meta.Key, obj *beta.Address) error

+ func (m *MockBetaAddresses) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Address, error)

+ func (m *MockBetaAddresses) Obj(o *beta.Address) *MockAddressesObj

+ type MockBetaBackendServices struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaBackendServices) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaBackendServices) (bool, *beta.BackendService, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.BackendService, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaBackendServices) (bool, []*beta.BackendService, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockBackendServicesObj

+ ProjectRouter ProjectRouter

+ SetSecurityPolicyHook func(context.Context, *meta.Key, *beta.SecurityPolicyReference, ...) error

+ UpdateHook func(context.Context, *meta.Key, *beta.BackendService, *MockBetaBackendServices) error

+ X interface{}

+ func NewMockBetaBackendServices(pr ProjectRouter, objs map[meta.Key]*MockBackendServicesObj) *MockBetaBackendServices

+ func (m *MockBetaBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaBackendServices) Get(ctx context.Context, key *meta.Key) (*beta.BackendService, error)

+ func (m *MockBetaBackendServices) Insert(ctx context.Context, key *meta.Key, obj *beta.BackendService) error

+ func (m *MockBetaBackendServices) List(ctx context.Context, fl *filter.F) ([]*beta.BackendService, error)

+ func (m *MockBetaBackendServices) Obj(o *beta.BackendService) *MockBackendServicesObj

+ func (m *MockBetaBackendServices) SetSecurityPolicy(ctx context.Context, key *meta.Key, arg0 *beta.SecurityPolicyReference) error

+ func (m *MockBetaBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *beta.BackendService) error

+ type MockBetaFirewalls struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaFirewalls) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaFirewalls) (bool, *beta.Firewall, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.Firewall, m *MockBetaFirewalls) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaFirewalls) (bool, []*beta.Firewall, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockFirewallsObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *beta.Firewall, *MockBetaFirewalls) error

+ X interface{}

+ func NewMockBetaFirewalls(pr ProjectRouter, objs map[meta.Key]*MockFirewallsObj) *MockBetaFirewalls

+ func (m *MockBetaFirewalls) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaFirewalls) Get(ctx context.Context, key *meta.Key) (*beta.Firewall, error)

+ func (m *MockBetaFirewalls) Insert(ctx context.Context, key *meta.Key, obj *beta.Firewall) error

+ func (m *MockBetaFirewalls) List(ctx context.Context, fl *filter.F) ([]*beta.Firewall, error)

+ func (m *MockBetaFirewalls) Obj(o *beta.Firewall) *MockFirewallsObj

+ func (m *MockBetaFirewalls) Update(ctx context.Context, key *meta.Key, arg0 *beta.Firewall) error

+ type MockBetaForwardingRules struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaForwardingRules) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaForwardingRules) (bool, *beta.ForwardingRule, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockBetaForwardingRules) (bool, []*beta.ForwardingRule, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockForwardingRulesObj

+ ProjectRouter ProjectRouter

+ SetTargetHook func(context.Context, *meta.Key, *beta.TargetReference, *MockBetaForwardingRules) error

+ X interface{}

+ func NewMockBetaForwardingRules(pr ProjectRouter, objs map[meta.Key]*MockForwardingRulesObj) *MockBetaForwardingRules

+ func (m *MockBetaForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaForwardingRules) Get(ctx context.Context, key *meta.Key) (*beta.ForwardingRule, error)

+ func (m *MockBetaForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule) error

+ func (m *MockBetaForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*beta.ForwardingRule, error)

+ func (m *MockBetaForwardingRules) Obj(o *beta.ForwardingRule) *MockForwardingRulesObj

+ func (m *MockBetaForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *beta.TargetReference) error

+ type MockBetaGlobalAddresses struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaGlobalAddresses) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaGlobalAddresses) (bool, *beta.Address, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.Address, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaGlobalAddresses) (bool, []*beta.Address, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockGlobalAddressesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaGlobalAddresses(pr ProjectRouter, objs map[meta.Key]*MockGlobalAddressesObj) *MockBetaGlobalAddresses

+ func (m *MockBetaGlobalAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaGlobalAddresses) Get(ctx context.Context, key *meta.Key) (*beta.Address, error)

+ func (m *MockBetaGlobalAddresses) Insert(ctx context.Context, key *meta.Key, obj *beta.Address) error

+ func (m *MockBetaGlobalAddresses) List(ctx context.Context, fl *filter.F) ([]*beta.Address, error)

+ func (m *MockBetaGlobalAddresses) Obj(o *beta.Address) *MockGlobalAddressesObj

+ type MockBetaGlobalForwardingRules struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaGlobalForwardingRules) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaGlobalForwardingRules) (bool, *beta.ForwardingRule, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaGlobalForwardingRules) (bool, []*beta.ForwardingRule, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockGlobalForwardingRulesObj

+ ProjectRouter ProjectRouter

+ SetTargetHook func(context.Context, *meta.Key, *beta.TargetReference, ...) error

+ X interface{}

+ func NewMockBetaGlobalForwardingRules(pr ProjectRouter, objs map[meta.Key]*MockGlobalForwardingRulesObj) *MockBetaGlobalForwardingRules

+ func (m *MockBetaGlobalForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaGlobalForwardingRules) Get(ctx context.Context, key *meta.Key) (*beta.ForwardingRule, error)

+ func (m *MockBetaGlobalForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *beta.ForwardingRule) error

+ func (m *MockBetaGlobalForwardingRules) List(ctx context.Context, fl *filter.F) ([]*beta.ForwardingRule, error)

+ func (m *MockBetaGlobalForwardingRules) Obj(o *beta.ForwardingRule) *MockGlobalForwardingRulesObj

+ func (m *MockBetaGlobalForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *beta.TargetReference) error

+ type MockBetaHealthChecks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaHealthChecks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaHealthChecks) (bool, *beta.HealthCheck, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.HealthCheck, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaHealthChecks) (bool, []*beta.HealthCheck, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockHealthChecksObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *beta.HealthCheck, *MockBetaHealthChecks) error

+ X interface{}

+ func NewMockBetaHealthChecks(pr ProjectRouter, objs map[meta.Key]*MockHealthChecksObj) *MockBetaHealthChecks

+ func (m *MockBetaHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaHealthChecks) Get(ctx context.Context, key *meta.Key) (*beta.HealthCheck, error)

+ func (m *MockBetaHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *beta.HealthCheck) error

+ func (m *MockBetaHealthChecks) List(ctx context.Context, fl *filter.F) ([]*beta.HealthCheck, error)

+ func (m *MockBetaHealthChecks) Obj(o *beta.HealthCheck) *MockHealthChecksObj

+ func (m *MockBetaHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *beta.HealthCheck) error

+ type MockBetaInstances struct

+ AttachDiskHook func(context.Context, *meta.Key, *beta.AttachedDisk, *MockBetaInstances) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaInstances) (bool, error)

+ DetachDiskHook func(context.Context, *meta.Key, string, *MockBetaInstances) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaInstances) (bool, *beta.Instance, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.Instance, m *MockBetaInstances) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, zone string, fl *filter.F, m *MockBetaInstances) (bool, []*beta.Instance, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockInstancesObj

+ ProjectRouter ProjectRouter

+ UpdateNetworkInterfaceHook func(context.Context, *meta.Key, string, *beta.NetworkInterface, *MockBetaInstances) error

+ X interface{}

+ func NewMockBetaInstances(pr ProjectRouter, objs map[meta.Key]*MockInstancesObj) *MockBetaInstances

+ func (m *MockBetaInstances) AttachDisk(ctx context.Context, key *meta.Key, arg0 *beta.AttachedDisk) error

+ func (m *MockBetaInstances) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaInstances) DetachDisk(ctx context.Context, key *meta.Key, arg0 string) error

+ func (m *MockBetaInstances) Get(ctx context.Context, key *meta.Key) (*beta.Instance, error)

+ func (m *MockBetaInstances) Insert(ctx context.Context, key *meta.Key, obj *beta.Instance) error

+ func (m *MockBetaInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*beta.Instance, error)

+ func (m *MockBetaInstances) Obj(o *beta.Instance) *MockInstancesObj

+ func (m *MockBetaInstances) UpdateNetworkInterface(ctx context.Context, key *meta.Key, arg0 string, arg1 *beta.NetworkInterface) error

+ type MockBetaNetworkEndpointGroups struct

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockBetaNetworkEndpointGroups) (bool, map[string][]*beta.NetworkEndpointGroup, error)

+ AttachNetworkEndpointsHook func(context.Context, *meta.Key, *beta.NetworkEndpointGroupsAttachEndpointsRequest, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaNetworkEndpointGroups) (bool, error)

+ DetachNetworkEndpointsHook func(context.Context, *meta.Key, *beta.NetworkEndpointGroupsDetachEndpointsRequest, ...) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaNetworkEndpointGroups) (bool, *beta.NetworkEndpointGroup, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.NetworkEndpointGroup, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, zone string, fl *filter.F, ...) (bool, []*beta.NetworkEndpointGroup, error)

+ ListNetworkEndpointsHook func(context.Context, *meta.Key, *beta.NetworkEndpointGroupsListEndpointsRequest, ...) ([]*beta.NetworkEndpointWithHealthStatus, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockNetworkEndpointGroupsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockNetworkEndpointGroupsObj) *MockBetaNetworkEndpointGroups

+ func (m *MockBetaNetworkEndpointGroups) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*beta.NetworkEndpointGroup, error)

+ func (m *MockBetaNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockBetaNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockBetaNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key) (*beta.NetworkEndpointGroup, error)

+ func (m *MockBetaNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *beta.NetworkEndpointGroup) error

+ func (m *MockBetaNetworkEndpointGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*beta.NetworkEndpointGroup, error)

+ func (m *MockBetaNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, ...) ([]*beta.NetworkEndpointWithHealthStatus, error)

+ func (m *MockBetaNetworkEndpointGroups) Obj(o *beta.NetworkEndpointGroup) *MockNetworkEndpointGroupsObj

+ type MockBetaNetworks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaNetworks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaNetworks) (bool, *beta.Network, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.Network, m *MockBetaNetworks) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaNetworks) (bool, []*beta.Network, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockNetworksObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaNetworks(pr ProjectRouter, objs map[meta.Key]*MockNetworksObj) *MockBetaNetworks

+ func (m *MockBetaNetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaNetworks) Get(ctx context.Context, key *meta.Key) (*beta.Network, error)

+ func (m *MockBetaNetworks) Insert(ctx context.Context, key *meta.Key, obj *beta.Network) error

+ func (m *MockBetaNetworks) List(ctx context.Context, fl *filter.F) ([]*beta.Network, error)

+ func (m *MockBetaNetworks) Obj(o *beta.Network) *MockNetworksObj

+ type MockBetaRegionBackendServices struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionBackendServices) (bool, error)

+ GetError map[meta.Key]error

+ GetHealthHook func(context.Context, *meta.Key, *beta.ResourceGroupReference, ...) (*beta.BackendServiceGroupHealth, error)

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionBackendServices) (bool, *beta.BackendService, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.BackendService, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*beta.BackendService, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionBackendServicesObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *beta.BackendService, ...) error

+ X interface{}

+ func NewMockBetaRegionBackendServices(pr ProjectRouter, objs map[meta.Key]*MockRegionBackendServicesObj) *MockBetaRegionBackendServices

+ func (m *MockBetaRegionBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaRegionBackendServices) Get(ctx context.Context, key *meta.Key) (*beta.BackendService, error)

+ func (m *MockBetaRegionBackendServices) GetHealth(ctx context.Context, key *meta.Key, arg0 *beta.ResourceGroupReference) (*beta.BackendServiceGroupHealth, error)

+ func (m *MockBetaRegionBackendServices) Insert(ctx context.Context, key *meta.Key, obj *beta.BackendService) error

+ func (m *MockBetaRegionBackendServices) List(ctx context.Context, region string, fl *filter.F) ([]*beta.BackendService, error)

+ func (m *MockBetaRegionBackendServices) Obj(o *beta.BackendService) *MockRegionBackendServicesObj

+ func (m *MockBetaRegionBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *beta.BackendService) error

+ type MockBetaRegionHealthChecks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionHealthChecks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionHealthChecks) (bool, *beta.HealthCheck, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.HealthCheck, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*beta.HealthCheck, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionHealthChecksObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *beta.HealthCheck, *MockBetaRegionHealthChecks) error

+ X interface{}

+ func NewMockBetaRegionHealthChecks(pr ProjectRouter, objs map[meta.Key]*MockRegionHealthChecksObj) *MockBetaRegionHealthChecks

+ func (m *MockBetaRegionHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaRegionHealthChecks) Get(ctx context.Context, key *meta.Key) (*beta.HealthCheck, error)

+ func (m *MockBetaRegionHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *beta.HealthCheck) error

+ func (m *MockBetaRegionHealthChecks) List(ctx context.Context, region string, fl *filter.F) ([]*beta.HealthCheck, error)

+ func (m *MockBetaRegionHealthChecks) Obj(o *beta.HealthCheck) *MockRegionHealthChecksObj

+ func (m *MockBetaRegionHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *beta.HealthCheck) error

+ type MockBetaRegionSslCertificates struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionSslCertificates) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionSslCertificates) (bool, *beta.SslCertificate, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.SslCertificate, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*beta.SslCertificate, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionSslCertificatesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaRegionSslCertificates(pr ProjectRouter, objs map[meta.Key]*MockRegionSslCertificatesObj) *MockBetaRegionSslCertificates

+ func (m *MockBetaRegionSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaRegionSslCertificates) Get(ctx context.Context, key *meta.Key) (*beta.SslCertificate, error)

+ func (m *MockBetaRegionSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *beta.SslCertificate) error

+ func (m *MockBetaRegionSslCertificates) List(ctx context.Context, region string, fl *filter.F) ([]*beta.SslCertificate, error)

+ func (m *MockBetaRegionSslCertificates) Obj(o *beta.SslCertificate) *MockRegionSslCertificatesObj

+ type MockBetaRegionTargetHttpProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionTargetHttpProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionTargetHttpProxies) (bool, *beta.TargetHttpProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.TargetHttpProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*beta.TargetHttpProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionTargetHttpProxiesObj

+ ProjectRouter ProjectRouter

+ SetUrlMapHook func(context.Context, *meta.Key, *beta.UrlMapReference, ...) error

+ X interface{}

+ func NewMockBetaRegionTargetHttpProxies(pr ProjectRouter, objs map[meta.Key]*MockRegionTargetHttpProxiesObj) *MockBetaRegionTargetHttpProxies

+ func (m *MockBetaRegionTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaRegionTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*beta.TargetHttpProxy, error)

+ func (m *MockBetaRegionTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *beta.TargetHttpProxy) error

+ func (m *MockBetaRegionTargetHttpProxies) List(ctx context.Context, region string, fl *filter.F) ([]*beta.TargetHttpProxy, error)

+ func (m *MockBetaRegionTargetHttpProxies) Obj(o *beta.TargetHttpProxy) *MockRegionTargetHttpProxiesObj

+ func (m *MockBetaRegionTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *beta.UrlMapReference) error

+ type MockBetaRegionTargetHttpsProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionTargetHttpsProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionTargetHttpsProxies) (bool, *beta.TargetHttpsProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.TargetHttpsProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*beta.TargetHttpsProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionTargetHttpsProxiesObj

+ ProjectRouter ProjectRouter

+ SetSslCertificatesHook func(context.Context, *meta.Key, ...) error

+ SetUrlMapHook func(context.Context, *meta.Key, *beta.UrlMapReference, ...) error

+ X interface{}

+ func NewMockBetaRegionTargetHttpsProxies(pr ProjectRouter, objs map[meta.Key]*MockRegionTargetHttpsProxiesObj) *MockBetaRegionTargetHttpsProxies

+ func (m *MockBetaRegionTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaRegionTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*beta.TargetHttpsProxy, error)

+ func (m *MockBetaRegionTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *beta.TargetHttpsProxy) error

+ func (m *MockBetaRegionTargetHttpsProxies) List(ctx context.Context, region string, fl *filter.F) ([]*beta.TargetHttpsProxy, error)

+ func (m *MockBetaRegionTargetHttpsProxies) Obj(o *beta.TargetHttpsProxy) *MockRegionTargetHttpsProxiesObj

+ func (m *MockBetaRegionTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockBetaRegionTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *beta.UrlMapReference) error

+ type MockBetaRegionUrlMaps struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionUrlMaps) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaRegionUrlMaps) (bool, *beta.UrlMap, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.UrlMap, m *MockBetaRegionUrlMaps) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockBetaRegionUrlMaps) (bool, []*beta.UrlMap, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionUrlMapsObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *beta.UrlMap, *MockBetaRegionUrlMaps) error

+ X interface{}

+ func NewMockBetaRegionUrlMaps(pr ProjectRouter, objs map[meta.Key]*MockRegionUrlMapsObj) *MockBetaRegionUrlMaps

+ func (m *MockBetaRegionUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaRegionUrlMaps) Get(ctx context.Context, key *meta.Key) (*beta.UrlMap, error)

+ func (m *MockBetaRegionUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *beta.UrlMap) error

+ func (m *MockBetaRegionUrlMaps) List(ctx context.Context, region string, fl *filter.F) ([]*beta.UrlMap, error)

+ func (m *MockBetaRegionUrlMaps) Obj(o *beta.UrlMap) *MockRegionUrlMapsObj

+ func (m *MockBetaRegionUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *beta.UrlMap) error

+ type MockBetaSecurityPolicies struct

+ AddRuleHook func(context.Context, *meta.Key, *beta.SecurityPolicyRule, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaSecurityPolicies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaSecurityPolicies) (bool, *beta.SecurityPolicy, error)

+ GetRuleHook func(context.Context, *meta.Key, *MockBetaSecurityPolicies) (*beta.SecurityPolicyRule, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.SecurityPolicy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaSecurityPolicies) (bool, []*beta.SecurityPolicy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockSecurityPoliciesObj

+ PatchHook func(context.Context, *meta.Key, *beta.SecurityPolicy, *MockBetaSecurityPolicies) error

+ PatchRuleHook func(context.Context, *meta.Key, *beta.SecurityPolicyRule, ...) error

+ ProjectRouter ProjectRouter

+ RemoveRuleHook func(context.Context, *meta.Key, *MockBetaSecurityPolicies) error

+ X interface{}

+ func NewMockBetaSecurityPolicies(pr ProjectRouter, objs map[meta.Key]*MockSecurityPoliciesObj) *MockBetaSecurityPolicies

+ func (m *MockBetaSecurityPolicies) AddRule(ctx context.Context, key *meta.Key, arg0 *beta.SecurityPolicyRule) error

+ func (m *MockBetaSecurityPolicies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaSecurityPolicies) Get(ctx context.Context, key *meta.Key) (*beta.SecurityPolicy, error)

+ func (m *MockBetaSecurityPolicies) GetRule(ctx context.Context, key *meta.Key) (*beta.SecurityPolicyRule, error)

+ func (m *MockBetaSecurityPolicies) Insert(ctx context.Context, key *meta.Key, obj *beta.SecurityPolicy) error

+ func (m *MockBetaSecurityPolicies) List(ctx context.Context, fl *filter.F) ([]*beta.SecurityPolicy, error)

+ func (m *MockBetaSecurityPolicies) Obj(o *beta.SecurityPolicy) *MockSecurityPoliciesObj

+ func (m *MockBetaSecurityPolicies) Patch(ctx context.Context, key *meta.Key, arg0 *beta.SecurityPolicy) error

+ func (m *MockBetaSecurityPolicies) PatchRule(ctx context.Context, key *meta.Key, arg0 *beta.SecurityPolicyRule) error

+ func (m *MockBetaSecurityPolicies) RemoveRule(ctx context.Context, key *meta.Key) error

+ type MockBetaSslCertificates struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaSslCertificates) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaSslCertificates) (bool, *beta.SslCertificate, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.SslCertificate, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaSslCertificates) (bool, []*beta.SslCertificate, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockSslCertificatesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaSslCertificates(pr ProjectRouter, objs map[meta.Key]*MockSslCertificatesObj) *MockBetaSslCertificates

+ func (m *MockBetaSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaSslCertificates) Get(ctx context.Context, key *meta.Key) (*beta.SslCertificate, error)

+ func (m *MockBetaSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *beta.SslCertificate) error

+ func (m *MockBetaSslCertificates) List(ctx context.Context, fl *filter.F) ([]*beta.SslCertificate, error)

+ func (m *MockBetaSslCertificates) Obj(o *beta.SslCertificate) *MockSslCertificatesObj

+ type MockBetaSubnetworks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaSubnetworks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaSubnetworks) (bool, *beta.Subnetwork, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.Subnetwork, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockBetaSubnetworks) (bool, []*beta.Subnetwork, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockSubnetworksObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockBetaSubnetworks(pr ProjectRouter, objs map[meta.Key]*MockSubnetworksObj) *MockBetaSubnetworks

+ func (m *MockBetaSubnetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaSubnetworks) Get(ctx context.Context, key *meta.Key) (*beta.Subnetwork, error)

+ func (m *MockBetaSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *beta.Subnetwork) error

+ func (m *MockBetaSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*beta.Subnetwork, error)

+ func (m *MockBetaSubnetworks) Obj(o *beta.Subnetwork) *MockSubnetworksObj

+ type MockBetaTargetHttpProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaTargetHttpProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaTargetHttpProxies) (bool, *beta.TargetHttpProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.TargetHttpProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaTargetHttpProxies) (bool, []*beta.TargetHttpProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTargetHttpProxiesObj

+ ProjectRouter ProjectRouter

+ SetUrlMapHook func(context.Context, *meta.Key, *beta.UrlMapReference, *MockBetaTargetHttpProxies) error

+ X interface{}

+ func NewMockBetaTargetHttpProxies(pr ProjectRouter, objs map[meta.Key]*MockTargetHttpProxiesObj) *MockBetaTargetHttpProxies

+ func (m *MockBetaTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*beta.TargetHttpProxy, error)

+ func (m *MockBetaTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *beta.TargetHttpProxy) error

+ func (m *MockBetaTargetHttpProxies) List(ctx context.Context, fl *filter.F) ([]*beta.TargetHttpProxy, error)

+ func (m *MockBetaTargetHttpProxies) Obj(o *beta.TargetHttpProxy) *MockTargetHttpProxiesObj

+ func (m *MockBetaTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *beta.UrlMapReference) error

+ type MockBetaTargetHttpsProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaTargetHttpsProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaTargetHttpsProxies) (bool, *beta.TargetHttpsProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.TargetHttpsProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaTargetHttpsProxies) (bool, []*beta.TargetHttpsProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTargetHttpsProxiesObj

+ ProjectRouter ProjectRouter

+ SetSslCertificatesHook func(context.Context, *meta.Key, *beta.TargetHttpsProxiesSetSslCertificatesRequest, ...) error

+ SetSslPolicyHook func(context.Context, *meta.Key, *beta.SslPolicyReference, ...) error

+ SetUrlMapHook func(context.Context, *meta.Key, *beta.UrlMapReference, *MockBetaTargetHttpsProxies) error

+ X interface{}

+ func NewMockBetaTargetHttpsProxies(pr ProjectRouter, objs map[meta.Key]*MockTargetHttpsProxiesObj) *MockBetaTargetHttpsProxies

+ func (m *MockBetaTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*beta.TargetHttpsProxy, error)

+ func (m *MockBetaTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *beta.TargetHttpsProxy) error

+ func (m *MockBetaTargetHttpsProxies) List(ctx context.Context, fl *filter.F) ([]*beta.TargetHttpsProxy, error)

+ func (m *MockBetaTargetHttpsProxies) Obj(o *beta.TargetHttpsProxy) *MockTargetHttpsProxiesObj

+ func (m *MockBetaTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockBetaTargetHttpsProxies) SetSslPolicy(ctx context.Context, key *meta.Key, arg0 *beta.SslPolicyReference) error

+ func (m *MockBetaTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *beta.UrlMapReference) error

+ type MockBetaTargetTcpProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaTargetTcpProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaTargetTcpProxies) (bool, *beta.TargetTcpProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.TargetTcpProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaTargetTcpProxies) (bool, []*beta.TargetTcpProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTargetTcpProxiesObj

+ ProjectRouter ProjectRouter

+ SetBackendServiceHook func(context.Context, *meta.Key, *beta.TargetTcpProxiesSetBackendServiceRequest, ...) error

+ X interface{}

+ func NewMockBetaTargetTcpProxies(pr ProjectRouter, objs map[meta.Key]*MockTargetTcpProxiesObj) *MockBetaTargetTcpProxies

+ func (m *MockBetaTargetTcpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaTargetTcpProxies) Get(ctx context.Context, key *meta.Key) (*beta.TargetTcpProxy, error)

+ func (m *MockBetaTargetTcpProxies) Insert(ctx context.Context, key *meta.Key, obj *beta.TargetTcpProxy) error

+ func (m *MockBetaTargetTcpProxies) List(ctx context.Context, fl *filter.F) ([]*beta.TargetTcpProxy, error)

+ func (m *MockBetaTargetTcpProxies) Obj(o *beta.TargetTcpProxy) *MockTargetTcpProxiesObj

+ func (m *MockBetaTargetTcpProxies) SetBackendService(ctx context.Context, key *meta.Key, ...) error

+ type MockBetaUrlMaps struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockBetaUrlMaps) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockBetaUrlMaps) (bool, *beta.UrlMap, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *beta.UrlMap, m *MockBetaUrlMaps) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockBetaUrlMaps) (bool, []*beta.UrlMap, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockUrlMapsObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *beta.UrlMap, *MockBetaUrlMaps) error

+ X interface{}

+ func NewMockBetaUrlMaps(pr ProjectRouter, objs map[meta.Key]*MockUrlMapsObj) *MockBetaUrlMaps

+ func (m *MockBetaUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockBetaUrlMaps) Get(ctx context.Context, key *meta.Key) (*beta.UrlMap, error)

+ func (m *MockBetaUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *beta.UrlMap) error

+ func (m *MockBetaUrlMaps) List(ctx context.Context, fl *filter.F) ([]*beta.UrlMap, error)

+ func (m *MockBetaUrlMaps) Obj(o *beta.UrlMap) *MockUrlMapsObj

+ func (m *MockBetaUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *beta.UrlMap) error

+ type MockDisks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockDisks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockDisks) (bool, *ga.Disk, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Disk, m *MockDisks) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, zone string, fl *filter.F, m *MockDisks) (bool, []*ga.Disk, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockDisksObj

+ ProjectRouter ProjectRouter

+ ResizeHook func(context.Context, *meta.Key, *ga.DisksResizeRequest, *MockDisks) error

+ X interface{}

+ func NewMockDisks(pr ProjectRouter, objs map[meta.Key]*MockDisksObj) *MockDisks

+ func (m *MockDisks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockDisks) Get(ctx context.Context, key *meta.Key) (*ga.Disk, error)

+ func (m *MockDisks) Insert(ctx context.Context, key *meta.Key, obj *ga.Disk) error

+ func (m *MockDisks) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Disk, error)

+ func (m *MockDisks) Obj(o *ga.Disk) *MockDisksObj

+ func (m *MockDisks) Resize(ctx context.Context, key *meta.Key, arg0 *ga.DisksResizeRequest) error

+ type MockDisksObj struct

+ Obj interface{}

+ func (m *MockDisksObj) ToGA() *ga.Disk

+ type MockFirewalls struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockFirewalls) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockFirewalls) (bool, *ga.Firewall, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Firewall, m *MockFirewalls) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockFirewalls) (bool, []*ga.Firewall, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockFirewallsObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *ga.Firewall, *MockFirewalls) error

+ X interface{}

+ func NewMockFirewalls(pr ProjectRouter, objs map[meta.Key]*MockFirewallsObj) *MockFirewalls

+ func (m *MockFirewalls) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockFirewalls) Get(ctx context.Context, key *meta.Key) (*ga.Firewall, error)

+ func (m *MockFirewalls) Insert(ctx context.Context, key *meta.Key, obj *ga.Firewall) error

+ func (m *MockFirewalls) List(ctx context.Context, fl *filter.F) ([]*ga.Firewall, error)

+ func (m *MockFirewalls) Obj(o *ga.Firewall) *MockFirewallsObj

+ func (m *MockFirewalls) Update(ctx context.Context, key *meta.Key, arg0 *ga.Firewall) error

+ type MockFirewallsObj struct

+ Obj interface{}

+ func (m *MockFirewallsObj) ToAlpha() *alpha.Firewall

+ func (m *MockFirewallsObj) ToBeta() *beta.Firewall

+ func (m *MockFirewallsObj) ToGA() *ga.Firewall

+ type MockForwardingRules struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockForwardingRules) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockForwardingRules) (bool, *ga.ForwardingRule, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.ForwardingRule, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockForwardingRules) (bool, []*ga.ForwardingRule, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockForwardingRulesObj

+ ProjectRouter ProjectRouter

+ SetTargetHook func(context.Context, *meta.Key, *ga.TargetReference, *MockForwardingRules) error

+ X interface{}

+ func NewMockForwardingRules(pr ProjectRouter, objs map[meta.Key]*MockForwardingRulesObj) *MockForwardingRules

+ func (m *MockForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockForwardingRules) Get(ctx context.Context, key *meta.Key) (*ga.ForwardingRule, error)

+ func (m *MockForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *ga.ForwardingRule) error

+ func (m *MockForwardingRules) List(ctx context.Context, region string, fl *filter.F) ([]*ga.ForwardingRule, error)

+ func (m *MockForwardingRules) Obj(o *ga.ForwardingRule) *MockForwardingRulesObj

+ func (m *MockForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *ga.TargetReference) error

+ type MockForwardingRulesObj struct

+ Obj interface{}

+ func (m *MockForwardingRulesObj) ToAlpha() *alpha.ForwardingRule

+ func (m *MockForwardingRulesObj) ToBeta() *beta.ForwardingRule

+ func (m *MockForwardingRulesObj) ToGA() *ga.ForwardingRule

+ type MockGCE struct

+ MockAddresses *MockAddresses

+ MockAlphaAddresses *MockAlphaAddresses

+ MockAlphaBackendServices *MockAlphaBackendServices

+ MockAlphaFirewalls *MockAlphaFirewalls

+ MockAlphaForwardingRules *MockAlphaForwardingRules

+ MockAlphaGlobalAddresses *MockAlphaGlobalAddresses

+ MockAlphaGlobalForwardingRules *MockAlphaGlobalForwardingRules

+ MockAlphaHealthChecks *MockAlphaHealthChecks

+ MockAlphaInstances *MockAlphaInstances

+ MockAlphaNetworkEndpointGroups *MockAlphaNetworkEndpointGroups

+ MockAlphaNetworks *MockAlphaNetworks

+ MockAlphaRegionBackendServices *MockAlphaRegionBackendServices

+ MockAlphaRegionHealthChecks *MockAlphaRegionHealthChecks

+ MockAlphaRegionSslCertificates *MockAlphaRegionSslCertificates

+ MockAlphaRegionTargetHttpProxies *MockAlphaRegionTargetHttpProxies

+ MockAlphaRegionTargetHttpsProxies *MockAlphaRegionTargetHttpsProxies

+ MockAlphaRegionUrlMaps *MockAlphaRegionUrlMaps

+ MockAlphaServiceAttachments *MockAlphaServiceAttachments

+ MockAlphaSslCertificates *MockAlphaSslCertificates

+ MockAlphaSubnetworks *MockAlphaSubnetworks

+ MockAlphaTargetHttpProxies *MockAlphaTargetHttpProxies

+ MockAlphaTargetHttpsProxies *MockAlphaTargetHttpsProxies

+ MockAlphaTargetTcpProxies *MockAlphaTargetTcpProxies

+ MockAlphaUrlMaps *MockAlphaUrlMaps

+ MockBackendServices *MockBackendServices

+ MockBetaAddresses *MockBetaAddresses

+ MockBetaBackendServices *MockBetaBackendServices

+ MockBetaFirewalls *MockBetaFirewalls

+ MockBetaForwardingRules *MockBetaForwardingRules

+ MockBetaGlobalAddresses *MockBetaGlobalAddresses

+ MockBetaGlobalForwardingRules *MockBetaGlobalForwardingRules

+ MockBetaHealthChecks *MockBetaHealthChecks

+ MockBetaInstances *MockBetaInstances

+ MockBetaNetworkEndpointGroups *MockBetaNetworkEndpointGroups

+ MockBetaNetworks *MockBetaNetworks

+ MockBetaRegionBackendServices *MockBetaRegionBackendServices

+ MockBetaRegionHealthChecks *MockBetaRegionHealthChecks

+ MockBetaRegionSslCertificates *MockBetaRegionSslCertificates

+ MockBetaRegionTargetHttpProxies *MockBetaRegionTargetHttpProxies

+ MockBetaRegionTargetHttpsProxies *MockBetaRegionTargetHttpsProxies

+ MockBetaRegionUrlMaps *MockBetaRegionUrlMaps

+ MockBetaSecurityPolicies *MockBetaSecurityPolicies

+ MockBetaSslCertificates *MockBetaSslCertificates

+ MockBetaSubnetworks *MockBetaSubnetworks

+ MockBetaTargetHttpProxies *MockBetaTargetHttpProxies

+ MockBetaTargetHttpsProxies *MockBetaTargetHttpsProxies

+ MockBetaTargetTcpProxies *MockBetaTargetTcpProxies

+ MockBetaUrlMaps *MockBetaUrlMaps

+ MockDisks *MockDisks

+ MockFirewalls *MockFirewalls

+ MockForwardingRules *MockForwardingRules

+ MockGlobalAddresses *MockGlobalAddresses

+ MockGlobalForwardingRules *MockGlobalForwardingRules

+ MockHealthChecks *MockHealthChecks

+ MockHttpHealthChecks *MockHttpHealthChecks

+ MockHttpsHealthChecks *MockHttpsHealthChecks

+ MockInstanceGroups *MockInstanceGroups

+ MockInstances *MockInstances

+ MockNetworkEndpointGroups *MockNetworkEndpointGroups

+ MockNetworks *MockNetworks

+ MockProjects *MockProjects

+ MockRegionBackendServices *MockRegionBackendServices

+ MockRegionDisks *MockRegionDisks

+ MockRegionHealthChecks *MockRegionHealthChecks

+ MockRegionSslCertificates *MockRegionSslCertificates

+ MockRegionTargetHttpProxies *MockRegionTargetHttpProxies

+ MockRegionTargetHttpsProxies *MockRegionTargetHttpsProxies

+ MockRegionUrlMaps *MockRegionUrlMaps

+ MockRegions *MockRegions

+ MockRoutes *MockRoutes

+ MockSslCertificates *MockSslCertificates

+ MockSslPolicies *MockSslPolicies

+ MockSubnetworks *MockSubnetworks

+ MockTargetHttpProxies *MockTargetHttpProxies

+ MockTargetHttpsProxies *MockTargetHttpsProxies

+ MockTargetPools *MockTargetPools

+ MockUrlMaps *MockUrlMaps

+ MockZones *MockZones

+ func NewMockGCE(projectRouter ProjectRouter) *MockGCE

+ func (mock *MockGCE) Addresses() Addresses

+ func (mock *MockGCE) AlphaAddresses() AlphaAddresses

+ func (mock *MockGCE) AlphaBackendServices() AlphaBackendServices

+ func (mock *MockGCE) AlphaFirewalls() AlphaFirewalls

+ func (mock *MockGCE) AlphaForwardingRules() AlphaForwardingRules

+ func (mock *MockGCE) AlphaGlobalAddresses() AlphaGlobalAddresses

+ func (mock *MockGCE) AlphaGlobalForwardingRules() AlphaGlobalForwardingRules

+ func (mock *MockGCE) AlphaHealthChecks() AlphaHealthChecks

+ func (mock *MockGCE) AlphaInstances() AlphaInstances

+ func (mock *MockGCE) AlphaNetworkEndpointGroups() AlphaNetworkEndpointGroups

+ func (mock *MockGCE) AlphaNetworks() AlphaNetworks

+ func (mock *MockGCE) AlphaRegionBackendServices() AlphaRegionBackendServices

+ func (mock *MockGCE) AlphaRegionHealthChecks() AlphaRegionHealthChecks

+ func (mock *MockGCE) AlphaRegionSslCertificates() AlphaRegionSslCertificates

+ func (mock *MockGCE) AlphaRegionTargetHttpProxies() AlphaRegionTargetHttpProxies

+ func (mock *MockGCE) AlphaRegionTargetHttpsProxies() AlphaRegionTargetHttpsProxies

+ func (mock *MockGCE) AlphaRegionUrlMaps() AlphaRegionUrlMaps

+ func (mock *MockGCE) AlphaServiceAttachments() AlphaServiceAttachments

+ func (mock *MockGCE) AlphaSslCertificates() AlphaSslCertificates

+ func (mock *MockGCE) AlphaSubnetworks() AlphaSubnetworks

+ func (mock *MockGCE) AlphaTargetHttpProxies() AlphaTargetHttpProxies

+ func (mock *MockGCE) AlphaTargetHttpsProxies() AlphaTargetHttpsProxies

+ func (mock *MockGCE) AlphaTargetTcpProxies() AlphaTargetTcpProxies

+ func (mock *MockGCE) AlphaUrlMaps() AlphaUrlMaps

+ func (mock *MockGCE) BackendServices() BackendServices

+ func (mock *MockGCE) BetaAddresses() BetaAddresses

+ func (mock *MockGCE) BetaBackendServices() BetaBackendServices

+ func (mock *MockGCE) BetaFirewalls() BetaFirewalls

+ func (mock *MockGCE) BetaForwardingRules() BetaForwardingRules

+ func (mock *MockGCE) BetaGlobalAddresses() BetaGlobalAddresses

+ func (mock *MockGCE) BetaGlobalForwardingRules() BetaGlobalForwardingRules

+ func (mock *MockGCE) BetaHealthChecks() BetaHealthChecks

+ func (mock *MockGCE) BetaInstances() BetaInstances

+ func (mock *MockGCE) BetaNetworkEndpointGroups() BetaNetworkEndpointGroups

+ func (mock *MockGCE) BetaNetworks() BetaNetworks

+ func (mock *MockGCE) BetaRegionBackendServices() BetaRegionBackendServices

+ func (mock *MockGCE) BetaRegionHealthChecks() BetaRegionHealthChecks

+ func (mock *MockGCE) BetaRegionSslCertificates() BetaRegionSslCertificates

+ func (mock *MockGCE) BetaRegionTargetHttpProxies() BetaRegionTargetHttpProxies

+ func (mock *MockGCE) BetaRegionTargetHttpsProxies() BetaRegionTargetHttpsProxies

+ func (mock *MockGCE) BetaRegionUrlMaps() BetaRegionUrlMaps

+ func (mock *MockGCE) BetaSecurityPolicies() BetaSecurityPolicies

+ func (mock *MockGCE) BetaSslCertificates() BetaSslCertificates

+ func (mock *MockGCE) BetaSubnetworks() BetaSubnetworks

+ func (mock *MockGCE) BetaTargetHttpProxies() BetaTargetHttpProxies

+ func (mock *MockGCE) BetaTargetHttpsProxies() BetaTargetHttpsProxies

+ func (mock *MockGCE) BetaTargetTcpProxies() BetaTargetTcpProxies

+ func (mock *MockGCE) BetaUrlMaps() BetaUrlMaps

+ func (mock *MockGCE) Disks() Disks

+ func (mock *MockGCE) Firewalls() Firewalls

+ func (mock *MockGCE) ForwardingRules() ForwardingRules

+ func (mock *MockGCE) GlobalAddresses() GlobalAddresses

+ func (mock *MockGCE) GlobalForwardingRules() GlobalForwardingRules

+ func (mock *MockGCE) HealthChecks() HealthChecks

+ func (mock *MockGCE) HttpHealthChecks() HttpHealthChecks

+ func (mock *MockGCE) HttpsHealthChecks() HttpsHealthChecks

+ func (mock *MockGCE) InstanceGroups() InstanceGroups

+ func (mock *MockGCE) Instances() Instances

+ func (mock *MockGCE) NetworkEndpointGroups() NetworkEndpointGroups

+ func (mock *MockGCE) Networks() Networks

+ func (mock *MockGCE) Projects() Projects

+ func (mock *MockGCE) RegionBackendServices() RegionBackendServices

+ func (mock *MockGCE) RegionDisks() RegionDisks

+ func (mock *MockGCE) RegionHealthChecks() RegionHealthChecks

+ func (mock *MockGCE) RegionSslCertificates() RegionSslCertificates

+ func (mock *MockGCE) RegionTargetHttpProxies() RegionTargetHttpProxies

+ func (mock *MockGCE) RegionTargetHttpsProxies() RegionTargetHttpsProxies

+ func (mock *MockGCE) RegionUrlMaps() RegionUrlMaps

+ func (mock *MockGCE) Regions() Regions

+ func (mock *MockGCE) Routes() Routes

+ func (mock *MockGCE) SslCertificates() SslCertificates

+ func (mock *MockGCE) SslPolicies() SslPolicies

+ func (mock *MockGCE) Subnetworks() Subnetworks

+ func (mock *MockGCE) TargetHttpProxies() TargetHttpProxies

+ func (mock *MockGCE) TargetHttpsProxies() TargetHttpsProxies

+ func (mock *MockGCE) TargetPools() TargetPools

+ func (mock *MockGCE) UrlMaps() UrlMaps

+ func (mock *MockGCE) Zones() Zones

+ type MockGlobalAddresses struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockGlobalAddresses) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockGlobalAddresses) (bool, *ga.Address, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Address, m *MockGlobalAddresses) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockGlobalAddresses) (bool, []*ga.Address, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockGlobalAddressesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockGlobalAddresses(pr ProjectRouter, objs map[meta.Key]*MockGlobalAddressesObj) *MockGlobalAddresses

+ func (m *MockGlobalAddresses) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockGlobalAddresses) Get(ctx context.Context, key *meta.Key) (*ga.Address, error)

+ func (m *MockGlobalAddresses) Insert(ctx context.Context, key *meta.Key, obj *ga.Address) error

+ func (m *MockGlobalAddresses) List(ctx context.Context, fl *filter.F) ([]*ga.Address, error)

+ func (m *MockGlobalAddresses) Obj(o *ga.Address) *MockGlobalAddressesObj

+ type MockGlobalAddressesObj struct

+ Obj interface{}

+ func (m *MockGlobalAddressesObj) ToAlpha() *alpha.Address

+ func (m *MockGlobalAddressesObj) ToBeta() *beta.Address

+ func (m *MockGlobalAddressesObj) ToGA() *ga.Address

+ type MockGlobalForwardingRules struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockGlobalForwardingRules) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockGlobalForwardingRules) (bool, *ga.ForwardingRule, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.ForwardingRule, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockGlobalForwardingRules) (bool, []*ga.ForwardingRule, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockGlobalForwardingRulesObj

+ ProjectRouter ProjectRouter

+ SetTargetHook func(context.Context, *meta.Key, *ga.TargetReference, *MockGlobalForwardingRules) error

+ X interface{}

+ func NewMockGlobalForwardingRules(pr ProjectRouter, objs map[meta.Key]*MockGlobalForwardingRulesObj) *MockGlobalForwardingRules

+ func (m *MockGlobalForwardingRules) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockGlobalForwardingRules) Get(ctx context.Context, key *meta.Key) (*ga.ForwardingRule, error)

+ func (m *MockGlobalForwardingRules) Insert(ctx context.Context, key *meta.Key, obj *ga.ForwardingRule) error

+ func (m *MockGlobalForwardingRules) List(ctx context.Context, fl *filter.F) ([]*ga.ForwardingRule, error)

+ func (m *MockGlobalForwardingRules) Obj(o *ga.ForwardingRule) *MockGlobalForwardingRulesObj

+ func (m *MockGlobalForwardingRules) SetTarget(ctx context.Context, key *meta.Key, arg0 *ga.TargetReference) error

+ type MockGlobalForwardingRulesObj struct

+ Obj interface{}

+ func (m *MockGlobalForwardingRulesObj) ToAlpha() *alpha.ForwardingRule

+ func (m *MockGlobalForwardingRulesObj) ToBeta() *beta.ForwardingRule

+ func (m *MockGlobalForwardingRulesObj) ToGA() *ga.ForwardingRule

+ type MockHealthChecks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockHealthChecks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockHealthChecks) (bool, *ga.HealthCheck, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.HealthCheck, m *MockHealthChecks) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockHealthChecks) (bool, []*ga.HealthCheck, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockHealthChecksObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *ga.HealthCheck, *MockHealthChecks) error

+ X interface{}

+ func NewMockHealthChecks(pr ProjectRouter, objs map[meta.Key]*MockHealthChecksObj) *MockHealthChecks

+ func (m *MockHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockHealthChecks) Get(ctx context.Context, key *meta.Key) (*ga.HealthCheck, error)

+ func (m *MockHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *ga.HealthCheck) error

+ func (m *MockHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HealthCheck, error)

+ func (m *MockHealthChecks) Obj(o *ga.HealthCheck) *MockHealthChecksObj

+ func (m *MockHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *ga.HealthCheck) error

+ type MockHealthChecksObj struct

+ Obj interface{}

+ func (m *MockHealthChecksObj) ToAlpha() *alpha.HealthCheck

+ func (m *MockHealthChecksObj) ToBeta() *beta.HealthCheck

+ func (m *MockHealthChecksObj) ToGA() *ga.HealthCheck

+ type MockHttpHealthChecks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockHttpHealthChecks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockHttpHealthChecks) (bool, *ga.HttpHealthCheck, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.HttpHealthCheck, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockHttpHealthChecks) (bool, []*ga.HttpHealthCheck, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockHttpHealthChecksObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *ga.HttpHealthCheck, *MockHttpHealthChecks) error

+ X interface{}

+ func NewMockHttpHealthChecks(pr ProjectRouter, objs map[meta.Key]*MockHttpHealthChecksObj) *MockHttpHealthChecks

+ func (m *MockHttpHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockHttpHealthChecks) Get(ctx context.Context, key *meta.Key) (*ga.HttpHealthCheck, error)

+ func (m *MockHttpHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *ga.HttpHealthCheck) error

+ func (m *MockHttpHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpHealthCheck, error)

+ func (m *MockHttpHealthChecks) Obj(o *ga.HttpHealthCheck) *MockHttpHealthChecksObj

+ func (m *MockHttpHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *ga.HttpHealthCheck) error

+ type MockHttpHealthChecksObj struct

+ Obj interface{}

+ func (m *MockHttpHealthChecksObj) ToGA() *ga.HttpHealthCheck

+ type MockHttpsHealthChecks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockHttpsHealthChecks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockHttpsHealthChecks) (bool, *ga.HttpsHealthCheck, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.HttpsHealthCheck, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockHttpsHealthChecks) (bool, []*ga.HttpsHealthCheck, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockHttpsHealthChecksObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *ga.HttpsHealthCheck, *MockHttpsHealthChecks) error

+ X interface{}

+ func NewMockHttpsHealthChecks(pr ProjectRouter, objs map[meta.Key]*MockHttpsHealthChecksObj) *MockHttpsHealthChecks

+ func (m *MockHttpsHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockHttpsHealthChecks) Get(ctx context.Context, key *meta.Key) (*ga.HttpsHealthCheck, error)

+ func (m *MockHttpsHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *ga.HttpsHealthCheck) error

+ func (m *MockHttpsHealthChecks) List(ctx context.Context, fl *filter.F) ([]*ga.HttpsHealthCheck, error)

+ func (m *MockHttpsHealthChecks) Obj(o *ga.HttpsHealthCheck) *MockHttpsHealthChecksObj

+ func (m *MockHttpsHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *ga.HttpsHealthCheck) error

+ type MockHttpsHealthChecksObj struct

+ Obj interface{}

+ func (m *MockHttpsHealthChecksObj) ToGA() *ga.HttpsHealthCheck

+ type MockInstanceGroups struct

+ AddInstancesHook func(context.Context, *meta.Key, *ga.InstanceGroupsAddInstancesRequest, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockInstanceGroups) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockInstanceGroups) (bool, *ga.InstanceGroup, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.InstanceGroup, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, zone string, fl *filter.F, m *MockInstanceGroups) (bool, []*ga.InstanceGroup, error)

+ ListInstancesHook func(context.Context, *meta.Key, *ga.InstanceGroupsListInstancesRequest, *filter.F, ...) ([]*ga.InstanceWithNamedPorts, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockInstanceGroupsObj

+ ProjectRouter ProjectRouter

+ RemoveInstancesHook func(context.Context, *meta.Key, *ga.InstanceGroupsRemoveInstancesRequest, ...) error

+ SetNamedPortsHook func(context.Context, *meta.Key, *ga.InstanceGroupsSetNamedPortsRequest, ...) error

+ X interface{}

+ func NewMockInstanceGroups(pr ProjectRouter, objs map[meta.Key]*MockInstanceGroupsObj) *MockInstanceGroups

+ func (m *MockInstanceGroups) AddInstances(ctx context.Context, key *meta.Key, arg0 *ga.InstanceGroupsAddInstancesRequest) error

+ func (m *MockInstanceGroups) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockInstanceGroups) Get(ctx context.Context, key *meta.Key) (*ga.InstanceGroup, error)

+ func (m *MockInstanceGroups) Insert(ctx context.Context, key *meta.Key, obj *ga.InstanceGroup) error

+ func (m *MockInstanceGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.InstanceGroup, error)

+ func (m *MockInstanceGroups) ListInstances(ctx context.Context, key *meta.Key, ...) ([]*ga.InstanceWithNamedPorts, error)

+ func (m *MockInstanceGroups) Obj(o *ga.InstanceGroup) *MockInstanceGroupsObj

+ func (m *MockInstanceGroups) RemoveInstances(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockInstanceGroups) SetNamedPorts(ctx context.Context, key *meta.Key, ...) error

+ type MockInstanceGroupsObj struct

+ Obj interface{}

+ func (m *MockInstanceGroupsObj) ToGA() *ga.InstanceGroup

+ type MockInstances struct

+ AttachDiskHook func(context.Context, *meta.Key, *ga.AttachedDisk, *MockInstances) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockInstances) (bool, error)

+ DetachDiskHook func(context.Context, *meta.Key, string, *MockInstances) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockInstances) (bool, *ga.Instance, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Instance, m *MockInstances) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, zone string, fl *filter.F, m *MockInstances) (bool, []*ga.Instance, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockInstancesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockInstances(pr ProjectRouter, objs map[meta.Key]*MockInstancesObj) *MockInstances

+ func (m *MockInstances) AttachDisk(ctx context.Context, key *meta.Key, arg0 *ga.AttachedDisk) error

+ func (m *MockInstances) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockInstances) DetachDisk(ctx context.Context, key *meta.Key, arg0 string) error

+ func (m *MockInstances) Get(ctx context.Context, key *meta.Key) (*ga.Instance, error)

+ func (m *MockInstances) Insert(ctx context.Context, key *meta.Key, obj *ga.Instance) error

+ func (m *MockInstances) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.Instance, error)

+ func (m *MockInstances) Obj(o *ga.Instance) *MockInstancesObj

+ type MockInstancesObj struct

+ Obj interface{}

+ func (m *MockInstancesObj) ToAlpha() *alpha.Instance

+ func (m *MockInstancesObj) ToBeta() *beta.Instance

+ func (m *MockInstancesObj) ToGA() *ga.Instance

+ type MockNetworkEndpointGroups struct

+ AggregatedListError *error

+ AggregatedListHook func(ctx context.Context, fl *filter.F, m *MockNetworkEndpointGroups) (bool, map[string][]*ga.NetworkEndpointGroup, error)

+ AttachNetworkEndpointsHook func(context.Context, *meta.Key, *ga.NetworkEndpointGroupsAttachEndpointsRequest, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockNetworkEndpointGroups) (bool, error)

+ DetachNetworkEndpointsHook func(context.Context, *meta.Key, *ga.NetworkEndpointGroupsDetachEndpointsRequest, ...) error

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockNetworkEndpointGroups) (bool, *ga.NetworkEndpointGroup, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.NetworkEndpointGroup, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, zone string, fl *filter.F, m *MockNetworkEndpointGroups) (bool, []*ga.NetworkEndpointGroup, error)

+ ListNetworkEndpointsHook func(context.Context, *meta.Key, *ga.NetworkEndpointGroupsListEndpointsRequest, ...) ([]*ga.NetworkEndpointWithHealthStatus, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockNetworkEndpointGroupsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockNetworkEndpointGroups(pr ProjectRouter, objs map[meta.Key]*MockNetworkEndpointGroupsObj) *MockNetworkEndpointGroups

+ func (m *MockNetworkEndpointGroups) AggregatedList(ctx context.Context, fl *filter.F) (map[string][]*ga.NetworkEndpointGroup, error)

+ func (m *MockNetworkEndpointGroups) AttachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockNetworkEndpointGroups) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockNetworkEndpointGroups) DetachNetworkEndpoints(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockNetworkEndpointGroups) Get(ctx context.Context, key *meta.Key) (*ga.NetworkEndpointGroup, error)

+ func (m *MockNetworkEndpointGroups) Insert(ctx context.Context, key *meta.Key, obj *ga.NetworkEndpointGroup) error

+ func (m *MockNetworkEndpointGroups) List(ctx context.Context, zone string, fl *filter.F) ([]*ga.NetworkEndpointGroup, error)

+ func (m *MockNetworkEndpointGroups) ListNetworkEndpoints(ctx context.Context, key *meta.Key, ...) ([]*ga.NetworkEndpointWithHealthStatus, error)

+ func (m *MockNetworkEndpointGroups) Obj(o *ga.NetworkEndpointGroup) *MockNetworkEndpointGroupsObj

+ type MockNetworkEndpointGroupsObj struct

+ Obj interface{}

+ func (m *MockNetworkEndpointGroupsObj) ToAlpha() *alpha.NetworkEndpointGroup

+ func (m *MockNetworkEndpointGroupsObj) ToBeta() *beta.NetworkEndpointGroup

+ func (m *MockNetworkEndpointGroupsObj) ToGA() *ga.NetworkEndpointGroup

+ type MockNetworks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockNetworks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockNetworks) (bool, *ga.Network, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Network, m *MockNetworks) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockNetworks) (bool, []*ga.Network, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockNetworksObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockNetworks(pr ProjectRouter, objs map[meta.Key]*MockNetworksObj) *MockNetworks

+ func (m *MockNetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockNetworks) Get(ctx context.Context, key *meta.Key) (*ga.Network, error)

+ func (m *MockNetworks) Insert(ctx context.Context, key *meta.Key, obj *ga.Network) error

+ func (m *MockNetworks) List(ctx context.Context, fl *filter.F) ([]*ga.Network, error)

+ func (m *MockNetworks) Obj(o *ga.Network) *MockNetworksObj

+ type MockNetworksObj struct

+ Obj interface{}

+ func (m *MockNetworksObj) ToAlpha() *alpha.Network

+ func (m *MockNetworksObj) ToBeta() *beta.Network

+ func (m *MockNetworksObj) ToGA() *ga.Network

+ type MockProjectOpsState struct

+ type MockProjects struct

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockProjectsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockProjects(pr ProjectRouter, objs map[meta.Key]*MockProjectsObj) *MockProjects

+ func (m *MockProjects) Get(ctx context.Context, projectID string) (*compute.Project, error)

+ func (m *MockProjects) Obj(o *ga.Project) *MockProjectsObj

+ func (m *MockProjects) SetCommonInstanceMetadata(ctx context.Context, projectID string, meta *compute.Metadata) error

+ type MockProjectsObj struct

+ Obj interface{}

+ func (m *MockProjectsObj) ToGA() *ga.Project

+ type MockRegionBackendServices struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRegionBackendServices) (bool, error)

+ GetError map[meta.Key]error

+ GetHealthHook func(context.Context, *meta.Key, *ga.ResourceGroupReference, ...) (*ga.BackendServiceGroupHealth, error)

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRegionBackendServices) (bool, *ga.BackendService, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.BackendService, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockRegionBackendServices) (bool, []*ga.BackendService, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionBackendServicesObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *ga.BackendService, *MockRegionBackendServices) error

+ X interface{}

+ func NewMockRegionBackendServices(pr ProjectRouter, objs map[meta.Key]*MockRegionBackendServicesObj) *MockRegionBackendServices

+ func (m *MockRegionBackendServices) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockRegionBackendServices) Get(ctx context.Context, key *meta.Key) (*ga.BackendService, error)

+ func (m *MockRegionBackendServices) GetHealth(ctx context.Context, key *meta.Key, arg0 *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error)

+ func (m *MockRegionBackendServices) Insert(ctx context.Context, key *meta.Key, obj *ga.BackendService) error

+ func (m *MockRegionBackendServices) List(ctx context.Context, region string, fl *filter.F) ([]*ga.BackendService, error)

+ func (m *MockRegionBackendServices) Obj(o *ga.BackendService) *MockRegionBackendServicesObj

+ func (m *MockRegionBackendServices) Update(ctx context.Context, key *meta.Key, arg0 *ga.BackendService) error

+ type MockRegionBackendServicesObj struct

+ Obj interface{}

+ func (m *MockRegionBackendServicesObj) ToAlpha() *alpha.BackendService

+ func (m *MockRegionBackendServicesObj) ToBeta() *beta.BackendService

+ func (m *MockRegionBackendServicesObj) ToGA() *ga.BackendService

+ type MockRegionDisks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRegionDisks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRegionDisks) (bool, *ga.Disk, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Disk, m *MockRegionDisks) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockRegionDisks) (bool, []*ga.Disk, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionDisksObj

+ ProjectRouter ProjectRouter

+ ResizeHook func(context.Context, *meta.Key, *ga.RegionDisksResizeRequest, *MockRegionDisks) error

+ X interface{}

+ func NewMockRegionDisks(pr ProjectRouter, objs map[meta.Key]*MockRegionDisksObj) *MockRegionDisks

+ func (m *MockRegionDisks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockRegionDisks) Get(ctx context.Context, key *meta.Key) (*ga.Disk, error)

+ func (m *MockRegionDisks) Insert(ctx context.Context, key *meta.Key, obj *ga.Disk) error

+ func (m *MockRegionDisks) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Disk, error)

+ func (m *MockRegionDisks) Obj(o *ga.Disk) *MockRegionDisksObj

+ func (m *MockRegionDisks) Resize(ctx context.Context, key *meta.Key, arg0 *ga.RegionDisksResizeRequest) error

+ type MockRegionDisksObj struct

+ Obj interface{}

+ func (m *MockRegionDisksObj) ToGA() *ga.Disk

+ type MockRegionHealthChecks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRegionHealthChecks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRegionHealthChecks) (bool, *ga.HealthCheck, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.HealthCheck, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockRegionHealthChecks) (bool, []*ga.HealthCheck, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionHealthChecksObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *ga.HealthCheck, *MockRegionHealthChecks) error

+ X interface{}

+ func NewMockRegionHealthChecks(pr ProjectRouter, objs map[meta.Key]*MockRegionHealthChecksObj) *MockRegionHealthChecks

+ func (m *MockRegionHealthChecks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockRegionHealthChecks) Get(ctx context.Context, key *meta.Key) (*ga.HealthCheck, error)

+ func (m *MockRegionHealthChecks) Insert(ctx context.Context, key *meta.Key, obj *ga.HealthCheck) error

+ func (m *MockRegionHealthChecks) List(ctx context.Context, region string, fl *filter.F) ([]*ga.HealthCheck, error)

+ func (m *MockRegionHealthChecks) Obj(o *ga.HealthCheck) *MockRegionHealthChecksObj

+ func (m *MockRegionHealthChecks) Update(ctx context.Context, key *meta.Key, arg0 *ga.HealthCheck) error

+ type MockRegionHealthChecksObj struct

+ Obj interface{}

+ func (m *MockRegionHealthChecksObj) ToAlpha() *alpha.HealthCheck

+ func (m *MockRegionHealthChecksObj) ToBeta() *beta.HealthCheck

+ func (m *MockRegionHealthChecksObj) ToGA() *ga.HealthCheck

+ type MockRegionSslCertificates struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRegionSslCertificates) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRegionSslCertificates) (bool, *ga.SslCertificate, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.SslCertificate, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockRegionSslCertificates) (bool, []*ga.SslCertificate, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionSslCertificatesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockRegionSslCertificates(pr ProjectRouter, objs map[meta.Key]*MockRegionSslCertificatesObj) *MockRegionSslCertificates

+ func (m *MockRegionSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockRegionSslCertificates) Get(ctx context.Context, key *meta.Key) (*ga.SslCertificate, error)

+ func (m *MockRegionSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *ga.SslCertificate) error

+ func (m *MockRegionSslCertificates) List(ctx context.Context, region string, fl *filter.F) ([]*ga.SslCertificate, error)

+ func (m *MockRegionSslCertificates) Obj(o *ga.SslCertificate) *MockRegionSslCertificatesObj

+ type MockRegionSslCertificatesObj struct

+ Obj interface{}

+ func (m *MockRegionSslCertificatesObj) ToAlpha() *alpha.SslCertificate

+ func (m *MockRegionSslCertificatesObj) ToBeta() *beta.SslCertificate

+ func (m *MockRegionSslCertificatesObj) ToGA() *ga.SslCertificate

+ type MockRegionTargetHttpProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRegionTargetHttpProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRegionTargetHttpProxies) (bool, *ga.TargetHttpProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.TargetHttpProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*ga.TargetHttpProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionTargetHttpProxiesObj

+ ProjectRouter ProjectRouter

+ SetUrlMapHook func(context.Context, *meta.Key, *ga.UrlMapReference, *MockRegionTargetHttpProxies) error

+ X interface{}

+ func NewMockRegionTargetHttpProxies(pr ProjectRouter, objs map[meta.Key]*MockRegionTargetHttpProxiesObj) *MockRegionTargetHttpProxies

+ func (m *MockRegionTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockRegionTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*ga.TargetHttpProxy, error)

+ func (m *MockRegionTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetHttpProxy) error

+ func (m *MockRegionTargetHttpProxies) List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetHttpProxy, error)

+ func (m *MockRegionTargetHttpProxies) Obj(o *ga.TargetHttpProxy) *MockRegionTargetHttpProxiesObj

+ func (m *MockRegionTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *ga.UrlMapReference) error

+ type MockRegionTargetHttpProxiesObj struct

+ Obj interface{}

+ func (m *MockRegionTargetHttpProxiesObj) ToAlpha() *alpha.TargetHttpProxy

+ func (m *MockRegionTargetHttpProxiesObj) ToBeta() *beta.TargetHttpProxy

+ func (m *MockRegionTargetHttpProxiesObj) ToGA() *ga.TargetHttpProxy

+ type MockRegionTargetHttpsProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRegionTargetHttpsProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRegionTargetHttpsProxies) (bool, *ga.TargetHttpsProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.TargetHttpsProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, ...) (bool, []*ga.TargetHttpsProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionTargetHttpsProxiesObj

+ ProjectRouter ProjectRouter

+ SetSslCertificatesHook func(context.Context, *meta.Key, ...) error

+ SetUrlMapHook func(context.Context, *meta.Key, *ga.UrlMapReference, *MockRegionTargetHttpsProxies) error

+ X interface{}

+ func NewMockRegionTargetHttpsProxies(pr ProjectRouter, objs map[meta.Key]*MockRegionTargetHttpsProxiesObj) *MockRegionTargetHttpsProxies

+ func (m *MockRegionTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockRegionTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*ga.TargetHttpsProxy, error)

+ func (m *MockRegionTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetHttpsProxy) error

+ func (m *MockRegionTargetHttpsProxies) List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetHttpsProxy, error)

+ func (m *MockRegionTargetHttpsProxies) Obj(o *ga.TargetHttpsProxy) *MockRegionTargetHttpsProxiesObj

+ func (m *MockRegionTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockRegionTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *ga.UrlMapReference) error

+ type MockRegionTargetHttpsProxiesObj struct

+ Obj interface{}

+ func (m *MockRegionTargetHttpsProxiesObj) ToAlpha() *alpha.TargetHttpsProxy

+ func (m *MockRegionTargetHttpsProxiesObj) ToBeta() *beta.TargetHttpsProxy

+ func (m *MockRegionTargetHttpsProxiesObj) ToGA() *ga.TargetHttpsProxy

+ type MockRegionUrlMaps struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRegionUrlMaps) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRegionUrlMaps) (bool, *ga.UrlMap, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.UrlMap, m *MockRegionUrlMaps) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockRegionUrlMaps) (bool, []*ga.UrlMap, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionUrlMapsObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *ga.UrlMap, *MockRegionUrlMaps) error

+ X interface{}

+ func NewMockRegionUrlMaps(pr ProjectRouter, objs map[meta.Key]*MockRegionUrlMapsObj) *MockRegionUrlMaps

+ func (m *MockRegionUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockRegionUrlMaps) Get(ctx context.Context, key *meta.Key) (*ga.UrlMap, error)

+ func (m *MockRegionUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *ga.UrlMap) error

+ func (m *MockRegionUrlMaps) List(ctx context.Context, region string, fl *filter.F) ([]*ga.UrlMap, error)

+ func (m *MockRegionUrlMaps) Obj(o *ga.UrlMap) *MockRegionUrlMapsObj

+ func (m *MockRegionUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *ga.UrlMap) error

+ type MockRegionUrlMapsObj struct

+ Obj interface{}

+ func (m *MockRegionUrlMapsObj) ToAlpha() *alpha.UrlMap

+ func (m *MockRegionUrlMapsObj) ToBeta() *beta.UrlMap

+ func (m *MockRegionUrlMapsObj) ToGA() *ga.UrlMap

+ type MockRegions struct

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRegions) (bool, *ga.Region, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockRegions) (bool, []*ga.Region, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRegionsObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockRegions(pr ProjectRouter, objs map[meta.Key]*MockRegionsObj) *MockRegions

+ func (m *MockRegions) Get(ctx context.Context, key *meta.Key) (*ga.Region, error)

+ func (m *MockRegions) List(ctx context.Context, fl *filter.F) ([]*ga.Region, error)

+ func (m *MockRegions) Obj(o *ga.Region) *MockRegionsObj

+ type MockRegionsObj struct

+ Obj interface{}

+ func (m *MockRegionsObj) ToGA() *ga.Region

+ type MockRoutes struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockRoutes) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockRoutes) (bool, *ga.Route, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Route, m *MockRoutes) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockRoutes) (bool, []*ga.Route, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockRoutesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockRoutes(pr ProjectRouter, objs map[meta.Key]*MockRoutesObj) *MockRoutes

+ func (m *MockRoutes) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockRoutes) Get(ctx context.Context, key *meta.Key) (*ga.Route, error)

+ func (m *MockRoutes) Insert(ctx context.Context, key *meta.Key, obj *ga.Route) error

+ func (m *MockRoutes) List(ctx context.Context, fl *filter.F) ([]*ga.Route, error)

+ func (m *MockRoutes) Obj(o *ga.Route) *MockRoutesObj

+ type MockRoutesObj struct

+ Obj interface{}

+ func (m *MockRoutesObj) ToGA() *ga.Route

+ type MockSecurityPoliciesObj struct

+ Obj interface{}

+ func (m *MockSecurityPoliciesObj) ToBeta() *beta.SecurityPolicy

+ type MockServiceAttachmentsObj struct

+ Obj interface{}

+ func (m *MockServiceAttachmentsObj) ToAlpha() *alpha.ServiceAttachment

+ type MockSslCertificates struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockSslCertificates) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockSslCertificates) (bool, *ga.SslCertificate, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.SslCertificate, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockSslCertificates) (bool, []*ga.SslCertificate, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockSslCertificatesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockSslCertificates(pr ProjectRouter, objs map[meta.Key]*MockSslCertificatesObj) *MockSslCertificates

+ func (m *MockSslCertificates) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockSslCertificates) Get(ctx context.Context, key *meta.Key) (*ga.SslCertificate, error)

+ func (m *MockSslCertificates) Insert(ctx context.Context, key *meta.Key, obj *ga.SslCertificate) error

+ func (m *MockSslCertificates) List(ctx context.Context, fl *filter.F) ([]*ga.SslCertificate, error)

+ func (m *MockSslCertificates) Obj(o *ga.SslCertificate) *MockSslCertificatesObj

+ type MockSslCertificatesObj struct

+ Obj interface{}

+ func (m *MockSslCertificatesObj) ToAlpha() *alpha.SslCertificate

+ func (m *MockSslCertificatesObj) ToBeta() *beta.SslCertificate

+ func (m *MockSslCertificatesObj) ToGA() *ga.SslCertificate

+ type MockSslPolicies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockSslPolicies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockSslPolicies) (bool, *ga.SslPolicy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.SslPolicy, m *MockSslPolicies) (bool, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockSslPoliciesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockSslPolicies(pr ProjectRouter, objs map[meta.Key]*MockSslPoliciesObj) *MockSslPolicies

+ func (m *MockSslPolicies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockSslPolicies) Get(ctx context.Context, key *meta.Key) (*ga.SslPolicy, error)

+ func (m *MockSslPolicies) Insert(ctx context.Context, key *meta.Key, obj *ga.SslPolicy) error

+ func (m *MockSslPolicies) Obj(o *ga.SslPolicy) *MockSslPoliciesObj

+ type MockSslPoliciesObj struct

+ Obj interface{}

+ func (m *MockSslPoliciesObj) ToGA() *ga.SslPolicy

+ type MockSubnetworks struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockSubnetworks) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockSubnetworks) (bool, *ga.Subnetwork, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.Subnetwork, m *MockSubnetworks) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockSubnetworks) (bool, []*ga.Subnetwork, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockSubnetworksObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockSubnetworks(pr ProjectRouter, objs map[meta.Key]*MockSubnetworksObj) *MockSubnetworks

+ func (m *MockSubnetworks) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockSubnetworks) Get(ctx context.Context, key *meta.Key) (*ga.Subnetwork, error)

+ func (m *MockSubnetworks) Insert(ctx context.Context, key *meta.Key, obj *ga.Subnetwork) error

+ func (m *MockSubnetworks) List(ctx context.Context, region string, fl *filter.F) ([]*ga.Subnetwork, error)

+ func (m *MockSubnetworks) Obj(o *ga.Subnetwork) *MockSubnetworksObj

+ type MockSubnetworksObj struct

+ Obj interface{}

+ func (m *MockSubnetworksObj) ToAlpha() *alpha.Subnetwork

+ func (m *MockSubnetworksObj) ToBeta() *beta.Subnetwork

+ func (m *MockSubnetworksObj) ToGA() *ga.Subnetwork

+ type MockTargetHttpProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockTargetHttpProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockTargetHttpProxies) (bool, *ga.TargetHttpProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.TargetHttpProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockTargetHttpProxies) (bool, []*ga.TargetHttpProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTargetHttpProxiesObj

+ ProjectRouter ProjectRouter

+ SetUrlMapHook func(context.Context, *meta.Key, *ga.UrlMapReference, *MockTargetHttpProxies) error

+ X interface{}

+ func NewMockTargetHttpProxies(pr ProjectRouter, objs map[meta.Key]*MockTargetHttpProxiesObj) *MockTargetHttpProxies

+ func (m *MockTargetHttpProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockTargetHttpProxies) Get(ctx context.Context, key *meta.Key) (*ga.TargetHttpProxy, error)

+ func (m *MockTargetHttpProxies) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetHttpProxy) error

+ func (m *MockTargetHttpProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpProxy, error)

+ func (m *MockTargetHttpProxies) Obj(o *ga.TargetHttpProxy) *MockTargetHttpProxiesObj

+ func (m *MockTargetHttpProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *ga.UrlMapReference) error

+ type MockTargetHttpProxiesObj struct

+ Obj interface{}

+ func (m *MockTargetHttpProxiesObj) ToAlpha() *alpha.TargetHttpProxy

+ func (m *MockTargetHttpProxiesObj) ToBeta() *beta.TargetHttpProxy

+ func (m *MockTargetHttpProxiesObj) ToGA() *ga.TargetHttpProxy

+ type MockTargetHttpsProxies struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockTargetHttpsProxies) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockTargetHttpsProxies) (bool, *ga.TargetHttpsProxy, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.TargetHttpsProxy, ...) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockTargetHttpsProxies) (bool, []*ga.TargetHttpsProxy, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTargetHttpsProxiesObj

+ ProjectRouter ProjectRouter

+ SetSslCertificatesHook func(context.Context, *meta.Key, *ga.TargetHttpsProxiesSetSslCertificatesRequest, ...) error

+ SetSslPolicyHook func(context.Context, *meta.Key, *ga.SslPolicyReference, *MockTargetHttpsProxies) error

+ SetUrlMapHook func(context.Context, *meta.Key, *ga.UrlMapReference, *MockTargetHttpsProxies) error

+ X interface{}

+ func NewMockTargetHttpsProxies(pr ProjectRouter, objs map[meta.Key]*MockTargetHttpsProxiesObj) *MockTargetHttpsProxies

+ func (m *MockTargetHttpsProxies) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockTargetHttpsProxies) Get(ctx context.Context, key *meta.Key) (*ga.TargetHttpsProxy, error)

+ func (m *MockTargetHttpsProxies) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetHttpsProxy) error

+ func (m *MockTargetHttpsProxies) List(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpsProxy, error)

+ func (m *MockTargetHttpsProxies) Obj(o *ga.TargetHttpsProxy) *MockTargetHttpsProxiesObj

+ func (m *MockTargetHttpsProxies) SetSslCertificates(ctx context.Context, key *meta.Key, ...) error

+ func (m *MockTargetHttpsProxies) SetSslPolicy(ctx context.Context, key *meta.Key, arg0 *ga.SslPolicyReference) error

+ func (m *MockTargetHttpsProxies) SetUrlMap(ctx context.Context, key *meta.Key, arg0 *ga.UrlMapReference) error

+ type MockTargetHttpsProxiesObj struct

+ Obj interface{}

+ func (m *MockTargetHttpsProxiesObj) ToAlpha() *alpha.TargetHttpsProxy

+ func (m *MockTargetHttpsProxiesObj) ToBeta() *beta.TargetHttpsProxy

+ func (m *MockTargetHttpsProxiesObj) ToGA() *ga.TargetHttpsProxy

+ type MockTargetPools struct

+ AddInstanceHook func(context.Context, *meta.Key, *ga.TargetPoolsAddInstanceRequest, ...) error

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockTargetPools) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockTargetPools) (bool, *ga.TargetPool, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.TargetPool, m *MockTargetPools) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, region string, fl *filter.F, m *MockTargetPools) (bool, []*ga.TargetPool, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockTargetPoolsObj

+ ProjectRouter ProjectRouter

+ RemoveInstanceHook func(context.Context, *meta.Key, *ga.TargetPoolsRemoveInstanceRequest, ...) error

+ X interface{}

+ func NewMockTargetPools(pr ProjectRouter, objs map[meta.Key]*MockTargetPoolsObj) *MockTargetPools

+ func (m *MockTargetPools) AddInstance(ctx context.Context, key *meta.Key, arg0 *ga.TargetPoolsAddInstanceRequest) error

+ func (m *MockTargetPools) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockTargetPools) Get(ctx context.Context, key *meta.Key) (*ga.TargetPool, error)

+ func (m *MockTargetPools) Insert(ctx context.Context, key *meta.Key, obj *ga.TargetPool) error

+ func (m *MockTargetPools) List(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetPool, error)

+ func (m *MockTargetPools) Obj(o *ga.TargetPool) *MockTargetPoolsObj

+ func (m *MockTargetPools) RemoveInstance(ctx context.Context, key *meta.Key, arg0 *ga.TargetPoolsRemoveInstanceRequest) error

+ type MockTargetPoolsObj struct

+ Obj interface{}

+ func (m *MockTargetPoolsObj) ToGA() *ga.TargetPool

+ type MockTargetTcpProxiesObj struct

+ Obj interface{}

+ func (m *MockTargetTcpProxiesObj) ToAlpha() *alpha.TargetTcpProxy

+ func (m *MockTargetTcpProxiesObj) ToBeta() *beta.TargetTcpProxy

+ type MockUrlMaps struct

+ DeleteError map[meta.Key]error

+ DeleteHook func(ctx context.Context, key *meta.Key, m *MockUrlMaps) (bool, error)

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockUrlMaps) (bool, *ga.UrlMap, error)

+ InsertError map[meta.Key]error

+ InsertHook func(ctx context.Context, key *meta.Key, obj *ga.UrlMap, m *MockUrlMaps) (bool, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockUrlMaps) (bool, []*ga.UrlMap, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockUrlMapsObj

+ ProjectRouter ProjectRouter

+ UpdateHook func(context.Context, *meta.Key, *ga.UrlMap, *MockUrlMaps) error

+ X interface{}

+ func NewMockUrlMaps(pr ProjectRouter, objs map[meta.Key]*MockUrlMapsObj) *MockUrlMaps

+ func (m *MockUrlMaps) Delete(ctx context.Context, key *meta.Key) error

+ func (m *MockUrlMaps) Get(ctx context.Context, key *meta.Key) (*ga.UrlMap, error)

+ func (m *MockUrlMaps) Insert(ctx context.Context, key *meta.Key, obj *ga.UrlMap) error

+ func (m *MockUrlMaps) List(ctx context.Context, fl *filter.F) ([]*ga.UrlMap, error)

+ func (m *MockUrlMaps) Obj(o *ga.UrlMap) *MockUrlMapsObj

+ func (m *MockUrlMaps) Update(ctx context.Context, key *meta.Key, arg0 *ga.UrlMap) error

+ type MockUrlMapsObj struct

+ Obj interface{}

+ func (m *MockUrlMapsObj) ToAlpha() *alpha.UrlMap

+ func (m *MockUrlMapsObj) ToBeta() *beta.UrlMap

+ func (m *MockUrlMapsObj) ToGA() *ga.UrlMap

+ type MockZones struct

+ GetError map[meta.Key]error

+ GetHook func(ctx context.Context, key *meta.Key, m *MockZones) (bool, *ga.Zone, error)

+ ListError *error

+ ListHook func(ctx context.Context, fl *filter.F, m *MockZones) (bool, []*ga.Zone, error)

+ Lock sync.Mutex

+ Objects map[meta.Key]*MockZonesObj

+ ProjectRouter ProjectRouter

+ X interface{}

+ func NewMockZones(pr ProjectRouter, objs map[meta.Key]*MockZonesObj) *MockZones

+ func (m *MockZones) Get(ctx context.Context, key *meta.Key) (*ga.Zone, error)

+ func (m *MockZones) List(ctx context.Context, fl *filter.F) ([]*ga.Zone, error)

+ func (m *MockZones) Obj(o *ga.Zone) *MockZonesObj

+ type MockZonesObj struct

+ Obj interface{}

+ func (m *MockZonesObj) ToGA() *ga.Zone

+ type NetworkEndpointGroups interface

+ AggregatedList func(ctx context.Context, fl *filter.F) (map[string][]*ga.NetworkEndpointGroup, error)

+ AttachNetworkEndpoints func(context.Context, *meta.Key, *ga.NetworkEndpointGroupsAttachEndpointsRequest) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ DetachNetworkEndpoints func(context.Context, *meta.Key, *ga.NetworkEndpointGroupsDetachEndpointsRequest) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.NetworkEndpointGroup, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.NetworkEndpointGroup) error

+ List func(ctx context.Context, zone string, fl *filter.F) ([]*ga.NetworkEndpointGroup, error)

+ ListNetworkEndpoints func(context.Context, *meta.Key, *ga.NetworkEndpointGroupsListEndpointsRequest, ...) ([]*ga.NetworkEndpointWithHealthStatus, error)

+ type NetworkTier string

+ func NetworkTierGCEValueToType(s string) NetworkTier

+ func (n NetworkTier) ToGCEValue() string

+ type Networks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Network, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Network) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.Network, error)

+ type NopRateLimiter struct

+ func (*NopRateLimiter) Accept(ctx context.Context, key *RateLimitKey) error

+ type ProjectRouter interface

+ ProjectID func(ctx context.Context, version meta.Version, service string) string

+ type Projects interface

+ type ProjectsOps interface

+ Get func(ctx context.Context, projectID string) (*compute.Project, error)

+ SetCommonInstanceMetadata func(ctx context.Context, projectID string, m *compute.Metadata) error

+ type RateLimitKey struct

+ Operation string

+ ProjectID string

+ Service string

+ Version meta.Version

+ type RateLimiter interface

+ Accept func(ctx context.Context, key *RateLimitKey) error

+ type RegionBackendServices interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.BackendService, error)

+ GetHealth func(context.Context, *meta.Key, *ga.ResourceGroupReference) (*ga.BackendServiceGroupHealth, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.BackendService) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.BackendService, error)

+ Update func(context.Context, *meta.Key, *ga.BackendService) error

+ type RegionDisks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Disk, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Disk) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.Disk, error)

+ Resize func(context.Context, *meta.Key, *ga.RegionDisksResizeRequest) error

+ type RegionHealthChecks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.HealthCheck, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.HealthCheck) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.HealthCheck, error)

+ Update func(context.Context, *meta.Key, *ga.HealthCheck) error

+ type RegionSslCertificates interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.SslCertificate, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.SslCertificate) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.SslCertificate, error)

+ type RegionTargetHttpProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.TargetHttpProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.TargetHttpProxy) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetHttpProxy, error)

+ SetUrlMap func(context.Context, *meta.Key, *ga.UrlMapReference) error

+ type RegionTargetHttpsProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.TargetHttpsProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.TargetHttpsProxy) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetHttpsProxy, error)

+ SetSslCertificates func(context.Context, *meta.Key, ...) error

+ SetUrlMap func(context.Context, *meta.Key, *ga.UrlMapReference) error

+ type RegionUrlMaps interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.UrlMap, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.UrlMap) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.UrlMap, error)

+ Update func(context.Context, *meta.Key, *ga.UrlMap) error

+ type Regions interface

+ Get func(ctx context.Context, key *meta.Key) (*ga.Region, error)

+ List func(ctx context.Context, fl *filter.F) ([]*ga.Region, error)

+ type ResourceID struct

+ Key *meta.Key

+ ProjectID string

+ Resource string

+ func NewAddressesResourceID(project, region, name string) *ResourceID

+ func NewBackendServicesResourceID(project, name string) *ResourceID

+ func NewDisksResourceID(project, zone, name string) *ResourceID

+ func NewFirewallsResourceID(project, name string) *ResourceID

+ func NewForwardingRulesResourceID(project, region, name string) *ResourceID

+ func NewGlobalAddressesResourceID(project, name string) *ResourceID

+ func NewGlobalForwardingRulesResourceID(project, name string) *ResourceID

+ func NewHealthChecksResourceID(project, name string) *ResourceID

+ func NewHttpHealthChecksResourceID(project, name string) *ResourceID

+ func NewHttpsHealthChecksResourceID(project, name string) *ResourceID

+ func NewInstanceGroupsResourceID(project, zone, name string) *ResourceID

+ func NewInstancesResourceID(project, zone, name string) *ResourceID

+ func NewNetworkEndpointGroupsResourceID(project, zone, name string) *ResourceID

+ func NewNetworksResourceID(project, name string) *ResourceID

+ func NewProjectsResourceID(project string) *ResourceID

+ func NewRegionBackendServicesResourceID(project, region, name string) *ResourceID

+ func NewRegionDisksResourceID(project, region, name string) *ResourceID

+ func NewRegionHealthChecksResourceID(project, region, name string) *ResourceID

+ func NewRegionSslCertificatesResourceID(project, region, name string) *ResourceID

+ func NewRegionTargetHttpProxiesResourceID(project, region, name string) *ResourceID

+ func NewRegionTargetHttpsProxiesResourceID(project, region, name string) *ResourceID

+ func NewRegionUrlMapsResourceID(project, region, name string) *ResourceID

+ func NewRegionsResourceID(project, name string) *ResourceID

+ func NewRoutesResourceID(project, name string) *ResourceID

+ func NewSecurityPoliciesResourceID(project, name string) *ResourceID

+ func NewServiceAttachmentsResourceID(project, region, name string) *ResourceID

+ func NewSslCertificatesResourceID(project, name string) *ResourceID

+ func NewSslPoliciesResourceID(project, name string) *ResourceID

+ func NewSubnetworksResourceID(project, region, name string) *ResourceID

+ func NewTargetHttpProxiesResourceID(project, name string) *ResourceID

+ func NewTargetHttpsProxiesResourceID(project, name string) *ResourceID

+ func NewTargetPoolsResourceID(project, region, name string) *ResourceID

+ func NewTargetTcpProxiesResourceID(project, name string) *ResourceID

+ func NewUrlMapsResourceID(project, name string) *ResourceID

+ func NewZonesResourceID(project, name string) *ResourceID

+ func ParseResourceURL(url string) (*ResourceID, error)

+ func (r *ResourceID) Equal(other *ResourceID) bool

+ func (r *ResourceID) RelativeResourceName() string

+ func (r *ResourceID) ResourcePath() string

+ func (r *ResourceID) SelfLink(ver meta.Version) string

+ type Routes interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Route, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Route) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.Route, error)

+ type Service struct

+ Alpha *alpha.Service

+ Beta *beta.Service

+ GA *ga.Service

+ ProjectRouter ProjectRouter

+ RateLimiter RateLimiter

+ func (s *Service) WaitForCompletion(ctx context.Context, genericOp interface{}) error

+ type SingleProjectRouter struct

+ ID string

+ func (r *SingleProjectRouter) ProjectID(ctx context.Context, version meta.Version, service string) string

+ type SslCertificates interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.SslCertificate, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.SslCertificate) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.SslCertificate, error)

+ type SslPolicies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.SslPolicy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.SslPolicy) error

+ type Subnetworks interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.Subnetwork, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.Subnetwork) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.Subnetwork, error)

+ type TargetHttpProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.TargetHttpProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.TargetHttpProxy) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpProxy, error)

+ SetUrlMap func(context.Context, *meta.Key, *ga.UrlMapReference) error

+ type TargetHttpsProxies interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.TargetHttpsProxy, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.TargetHttpsProxy) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.TargetHttpsProxy, error)

+ SetSslCertificates func(context.Context, *meta.Key, *ga.TargetHttpsProxiesSetSslCertificatesRequest) error

+ SetSslPolicy func(context.Context, *meta.Key, *ga.SslPolicyReference) error

+ SetUrlMap func(context.Context, *meta.Key, *ga.UrlMapReference) error

+ type TargetPools interface

+ AddInstance func(context.Context, *meta.Key, *ga.TargetPoolsAddInstanceRequest) error

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.TargetPool, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.TargetPool) error

+ List func(ctx context.Context, region string, fl *filter.F) ([]*ga.TargetPool, error)

+ RemoveInstance func(context.Context, *meta.Key, *ga.TargetPoolsRemoveInstanceRequest) error

+ type UrlMaps interface

+ Delete func(ctx context.Context, key *meta.Key) error

+ Get func(ctx context.Context, key *meta.Key) (*ga.UrlMap, error)

+ Insert func(ctx context.Context, key *meta.Key, obj *ga.UrlMap) error

+ List func(ctx context.Context, fl *filter.F) ([]*ga.UrlMap, error)

+ Update func(context.Context, *meta.Key, *ga.UrlMap) error

+ type Zones interface

+ Get func(ctx context.Context, key *meta.Key) (*ga.Zone, error)

+ List func(ctx context.Context, fl *filter.F) ([]*ga.Zone, error)

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL