def Run(self, args):
args.GetDisplayInfo().AddTransforms({
'description':
_TransformShareSettings,
})
if args.share_settings:
args.GetDisplayInfo().AddFormat("""\
table(
name,
zone.basename(),
description,
nodeTemplate.basename(),
size:label=NODES,
shareSettings.description()
)""")
else:
args.GetDisplayInfo().AddFormat("""\
table(
name,
zone.basename(),
description,
nodeTemplate.basename(),
size:label=NODES,
shareSettings.yesno(yes="true", no="false"):label=SHARED
)""")
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client, aggregation_service=client.apitools_client.nodeGroups)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
"""Yields images from (potentially) multiple projects."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
def ParseProject(project):
return holder.resources.Parse(None, {'project': project},
collection='compute.projects')
if args.standard_images:
for project in constants.PUBLIC_IMAGE_PROJECTS:
request_data.scope_set.add(ParseProject(project))
if args.preview_images:
for project in constants.PREVIEW_IMAGE_PROJECTS:
request_data.scope_set.add(ParseProject(project))
list_implementation = lister.MultiScopeLister(
client, global_service=client.apitools_client.images)
images = lister.Invoke(request_data, list_implementation)
return self.AugmentImagesStatus(holder.resources,
self._FilterDeprecated(args, images))
def WarnIfSettingNonExistentRegionZone(prop, zonal=True):
"""Warn if setting 'compute/region' or 'compute/zone' to wrong value."""
zonal_msg = ('{} is not a valid zone. Run `gcloud compute zones list` to '
'get all zones.'.format(prop))
regional_msg = (
'{} is not a valid region. Run `gcloud compute regions list`'
'to get all regions.'.format(prop))
holder = base_classes.ComputeApiHolder(base.ReleaseTrack.GA)
client = holder.client
# pylint: disable=protected-access
request_data = lister._Frontend(
None, None,
lister.GlobalScope([
holder.resources.Parse(properties.VALUES.core.project.GetOrFail(),
collection='compute.projects')
]))
list_implementation = lister.GlobalLister(
client, client.apitools_client.zones
if zonal else client.apitools_client.regions)
try:
response = lister.Invoke(request_data, list_implementation)
zones = [i['name'] for i in list(response)]
if prop not in zones:
log.warning(zonal_msg if zonal else regional_msg)
except (lister.ListException, apitools_exceptions.HttpError,
c_store.NoCredentialsForAccountException,
api_lib_util_exceptions.HttpException):
log.warning('Property validation for compute/{} was skipped.'.format(
'zone' if zonal else 'region'))
def _Run(args, holder):
"""Issues requests necessary to list Target gRPC Proxies."""
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(
client, client.apitools_client.targetGrpcProxies)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client, aggregation_service=client.apitools_client.nodeGroups)
return lister.Invoke(request_data, list_implementation)
def _Run(args, holder):
"""Issues requests necessary to list service attachments."""
client = holder.client
request_data = lister.ParseRegionalFlags(args, holder.resources)
list_implementation = lister.RegionalLister(
client, client.apitools_client.serviceAttachments)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(
args, holder.resources, client.messages.PublicAdvertisedPrefix)
list_implementation = lister.GlobalLister(
client, client.apitools_client.publicAdvertisedPrefixes)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
request_data = lister.ParseRegionalFlags(args, holder.resources)
compute_client = holder.client
list_implementation = lister.RegionalLister(
compute_client, compute_client.apitools_client.packetMirrorings)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(
client, client.apitools_client.httpsHealthChecks)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseZonalFlags(args, holder.resources)
list_implementation = lister.ZonalParallelLister(
client, client.apitools_client.instances, holder.resources)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseRegionalFlags(args, holder.resources)
list_implementation = lister.RegionalLister(
client, client.apitools_client.targetVpnGateways)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(
client, client.apitools_client.networks)
return (networks_utils.AddModesForListFormat(resource)
for resource in lister.Invoke(request_data, list_implementation))
def Run(self, args):
log.status.Print(flags.LIST_NOTICE)
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(client,
client.apitools_client.firewalls)
return lister.Invoke(request_data, list_implementation)
def testInvoke(self):
frontend = object()
result = object()
def implementation(f):
self.assertFalse(self.called)
self.called = True
self.assertIs(f, frontend)
return result
self.assertIs(result, lister.Invoke(frontend, implementation))
self.assertTrue(self.called)
def _Run(args, holder):
"""Issues request necessary to list forwarding rules."""
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
regional_service=client.apitools_client.forwardingRules,
global_service=client.apitools_client.globalForwardingRules,
aggregation_service=client.apitools_client.forwardingRules)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
regional_service=client.apitools_client.regionSslCertificates,
global_service=client.apitools_client.sslCertificates,
aggregation_service=client.apitools_client.sslCertificates,
return_partial_success=self._return_partial_success)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
regional_service=client.apitools_client.publicDelegatedPrefixes,
global_service=client.apitools_client.
globalPublicDelegatedPrefixes,
aggregation_service=client.apitools_client.publicDelegatedPrefixes)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
zonal_service=client.apitools_client.instanceGroups,
regional_service=client.apitools_client.regionInstanceGroups,
aggregation_service=client.apitools_client.instanceGroups)
return self.ComputeDynamicProperties(
args, lister.Invoke(request_data, list_implementation), holder)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
zonal_service=client.apitools_client.networkEndpointGroups,
regional_service=client.apitools_client.regionNetworkEndpointGroups
if self.support_regional_scope else None,
global_service=client.apitools_client.globalNetworkEndpointGroups
if self.support_global_scope else None,
aggregation_service=client.apitools_client.networkEndpointGroups)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseRegionalFlags(args, holder.resources)
list_implementation = lister.RegionalLister(
client, client.apitools_client.subnetworks)
for resource in lister.Invoke(request_data, list_implementation):
if args.network is None:
yield resource
elif 'network' in resource:
network_ref = holder.resources.Parse(resource['network'])
if network_ref.Name() == args.network:
yield resource
def _Run(args, holder, include_l7_internal_load_balancing):
"""Issues requests necessary to list URL maps."""
client = holder.client
if include_l7_internal_load_balancing:
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
regional_service=client.apitools_client.regionUrlMaps,
global_service=client.apitools_client.urlMaps,
aggregation_service=client.apitools_client.urlMaps)
else:
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(
client, client.apitools_client.urlMaps)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseZonalFlags(args, holder.resources)
list_implementation = lister.ZonalLister(
client, client.apitools_client.instanceGroups)
results = lister.Invoke(request_data, list_implementation)
results = (resource for resource in results if 'zone' in resource)
return instance_groups_utils.ComputeInstanceGroupManagerMembership(
compute_holder=holder,
items=results,
filter_mode=instance_groups_utils.InstanceGroupFilteringMode.
ONLY_UNMANAGED_GROUPS)
def Run(self, args):
query = resource_filter.Compile(self._GetInventoryFilterQuery(args))
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
zonal_service=client.apitools_client.instances,
aggregation_service=client.apitools_client.instances)
instances_iterator = lister.Invoke(request_data, list_implementation)
instances = list(instances_iterator)
responses = self._GetAllGuestInventoryGuestAttributes(holder, instances)
return self._GetInventoryFilteredInstances(instances, responses, query)
def _Run(args, holder, include_l7_internal_load_balancing,
return_partial_success):
"""Issues requests necessary to list Target HTTPS Proxies."""
client = holder.client
if include_l7_internal_load_balancing:
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
regional_service=client.apitools_client.regionTargetHttpsProxies,
global_service=client.apitools_client.targetHttpsProxies,
aggregation_service=client.apitools_client.targetHttpsProxies,
return_partial_success=return_partial_success)
else:
request_data = lister.ParseNamesAndRegexpFlags(args, holder.resources)
list_implementation = lister.GlobalLister(
client, client.apitools_client.targetHttpsProxies)
return lister.Invoke(request_data, list_implementation)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
request_data = lister.ParseMultiScopeFlags(args, holder.resources)
list_implementation = lister.MultiScopeLister(
client,
zonal_service=client.apitools_client.instanceGroupManagers,
regional_service=client.apitools_client.regionInstanceGroupManagers,
aggregation_service=client.apitools_client.instanceGroupManagers)
migs = lister.Invoke(request_data, list_implementation)
(self._had_errors,
results) = managed_instance_groups_utils.AddAutoscaledPropertyToMigs(
list(migs), client, holder.resources)
return results
