class ListAlpha(List):
"""Lists Google Compute Engine network endpoint groups."""
detailed_help = base_classes.GetMultiScopeListerHelp(
'network endpoint groups', [
base_classes.ScopeType.zonal_scope,
base_classes.ScopeType.regional_scope,
base_classes.ScopeType.global_scope
])
support_regional_scope = True
def _DetailedHelp(include_l7_internal_load_balancing):
if include_l7_internal_load_balancing:
return base_classes.GetMultiScopeListerHelp(
'URL maps',
scopes=[
base_classes.ScopeType.global_scope,
base_classes.ScopeType.regional_scope
])
else:
return base_classes.GetGlobalListerHelp('URL maps')
class List(base.ListCommand):
"""Lists Compute Engine network endpoint groups."""
detailed_help = base_classes.GetMultiScopeListerHelp(
'network endpoint groups', [
base_classes.ScopeType.zonal_scope,
base_classes.ScopeType.regional_scope,
base_classes.ScopeType.global_scope
])
support_global_scope = True
support_regional_scope = True
return_partial_success = False
@classmethod
def Args(cls, parser):
parser.display_info.AddFormat("""\
table(
name,
selfLink.scope().segment(-3).yesno(no="global"):label=LOCATION,
networkEndpointType:label=ENDPOINT_TYPE,
size
)
""")
lister.AddMultiScopeListerFlags(parser,
zonal=True,
regional=cls.support_regional_scope,
global_=cls.support_global_scope)
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_partial_success=self.return_partial_success)
return lister.Invoke(request_data, list_implementation)
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)
@base.ReleaseTracks(base.ReleaseTrack.BETA, base.ReleaseTrack.ALPHA)
class ListBetaAlpha(List):
"""List Google Compute Engine managed instance groups."""
@staticmethod
def Args(parser):
_Args(parser)
def ComputeDynamicProperties(self, args, items, holder):
return instance_groups_utils.ComputeInstanceGroupManagerMembership(
compute_holder=holder,
items=items,
filter_mode=instance_groups_utils.InstanceGroupFilteringMode.ALL_GROUPS)
List.detailed_help = base_classes.GetMultiScopeListerHelp(
'instance groups', (base_classes.ScopeType.regional_scope,
base_classes.ScopeType.zonal_scope))
ListBetaAlpha.detailed_help = List.detailed_help
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
class ListAlpha(base.ListCommand):
"""List Target HTTP Proxies.."""
@classmethod
def Args(cls, parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
lister.AddMultiScopeListerFlags(parser, regional=True, global_=True)
parser.display_info.AddCacheUpdater(
flags.TargetHttpProxiesCompleterAlpha)
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.regionTargetHttpProxies,
global_service=client.apitools_client.targetHttpProxies,
aggregation_service=client.apitools_client.targetHttpProxies)
return lister.Invoke(request_data, list_implementation)
ListAlpha.detailed_help = base_classes.GetMultiScopeListerHelp(
'target HTTP proxies',
scopes=[
base_classes.ScopeType.global_scope,
base_classes.ScopeType.regional_scope
])
location_scope(),
sizeGb,
type.basename(),
status)
""")
lister.AddMultiScopeListerFlags(parser, zonal=True, regional=True)
parser.display_info.AddCacheUpdater(completers.DisksCompleter)
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.disks,
regional_service=client.apitools_client.regionDisks,
aggregation_service=client.apitools_client.disks)
return lister.Invoke(request_data, list_implementation)
List.detailed_help = base_classes.GetZonalListerHelp('disks')
ListAlpha.detailed_help = base_classes.GetMultiScopeListerHelp(
'disks',
scopes=[
base_classes.ScopeType.zonal_scope,
base_classes.ScopeType.regional_scope
])
name,
selfLink.scope().segment(-3).yesno(no="global"):label=LOCATION,
networkEndpointType:label=ENDPOINT_TYPE,
size
)
""")
lister.AddMultiScopeListerFlags(
parser, zonal=True, regional=True, global_=True)
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,
global_service=client.apitools_client.globalNetworkEndpointGroups,
aggregation_service=client.apitools_client.networkEndpointGroups)
return lister.Invoke(request_data, list_implementation)
ListAlpha.detailed_help = base_classes.GetMultiScopeListerHelp(
'network endpoint groups', [
base_classes.ScopeType.zonal_scope,
base_classes.ScopeType.regional_scope,
base_classes.ScopeType.global_scope
])
return instance_groups_utils.ComputeInstanceGroupManagerMembership(
compute=self.compute,
resources=self.resources,
http=self.http,
batch_url=self.batch_url,
items=items,
filter_mode=mode)
@base.ReleaseTracks(base.ReleaseTrack.BETA, base.ReleaseTrack.ALPHA)
class ListBetaAlpha(List):
"""List Google Compute Engine managed instance groups."""
@staticmethod
def Args(parser):
base_classes.MultiScopeLister.AddScopeArgs(parser, List.SCOPES)
def ComputeDynamicProperties(self, args, items):
return instance_groups_utils.ComputeInstanceGroupManagerMembership(
compute=self.compute,
resources=self.resources,
http=self.http,
batch_url=self.batch_url,
items=items,
filter_mode=instance_groups_utils.InstanceGroupFilteringMode.
ALL_GROUPS)
List.detailed_help = base_classes.GetMultiScopeListerHelp(
'instance groups', List.SCOPES)
ListBetaAlpha.detailed_help = List.detailed_help
@base.ReleaseTracks(base.ReleaseTrack.BETA, base.ReleaseTrack.GA,
base.ReleaseTrack.ALPHA)
class List(base.ListCommand):
"""List Compute Engine SSL certificates."""
@staticmethod
def Args(parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
lister.AddMultiScopeListerFlags(parser, regional=True, global_=True)
parser.display_info.AddCacheUpdater(flags.SslCertificatesCompleterBeta)
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 lister.Invoke(request_data, list_implementation)
List.detailed_help = base_classes.GetMultiScopeListerHelp(
'SSL certificates',
scopes=[
base_classes.ScopeType.global_scope,
base_classes.ScopeType.regional_scope
])
disk_types_lists += disk_in_scope.value.diskTypes
return disk_types_lists, response.nextPageToken
def Collection(self):
return 'compute.diskTypes.alpha'
def Run(self, args):
compute_disk_types = apis.GetClientInstance('compute', 'alpha').diskTypes
messages = apis.GetMessagesModule('compute', 'alpha')
request = messages.ComputeDiskTypesAggregatedListRequest(
filter=self._GetFilter(
args.names, args.regexp, args.zones, args.regions),
project=properties.VALUES.core.project.Get(required=True),
)
# TODO(b/34871930): Write and use helper for handling listing.
disk_types_lists, next_page_token = self._GetListPage(
compute_disk_types, request)
while next_page_token:
request.pageToken = next_page_token
disk_types_list_page, next_page_token = self._GetListPage(
compute_disk_types, request)
disk_types_lists += disk_types_list_page
return disk_types_lists
List.detailed_help = base_classes.GetZonalListerHelp('disk types')
ListAlpha.detailed_help = base_classes.GetMultiScopeListerHelp(
'disk types', ListAlpha.SCOPES)
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
class ListAlpha(base.ListCommand):
"""List URL maps."""
@staticmethod
def Args(parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
lister.AddMultiScopeListerFlags(parser, regional=True, global_=True)
parser.display_info.AddCacheUpdater(flags.UrlMapsCompleterAlpha)
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.regionUrlMaps,
global_service=client.apitools_client.urlMaps,
aggregation_service=client.apitools_client.urlMaps)
return lister.Invoke(request_data, list_implementation)
ListAlpha.detailed_help = base_classes.GetMultiScopeListerHelp(
'URL maps',
scopes=[
base_classes.ScopeType.global_scope,
base_classes.ScopeType.regional_scope
])
@property
def regional_service(self):
return self.compute.regionInstanceGroupManagers
@property
def zonal_service(self):
return self.compute.instanceGroupManagers
@property
def aggregation_service(self):
return self.compute.instanceGroupManagers
@property
def resource_type(self):
return 'instanceGroupManagers'
def GetResources(self, args, errors):
self._had_errors = False
return super(ListBeta, self).GetResources(args, errors)
def Epilog(self, unused_resources_were_displayed):
if self._had_errors:
log.err.Print(
'(*) - there are errors in your autoscaling setup, please '
'describe the resource to see details')
List.detailed_help = base_classes.GetZonalListerHelp('managed instance groups')
ListBeta.detailed_help = base_classes.GetMultiScopeListerHelp(
'managed instance groups', ListBeta.SCOPES)
