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):
"""List target gRPC proxies."""
detailed_help = base_classes.GetGlobalListerHelp('target gRPC proxies')
@classmethod
def Args(cls, parser):
_Args(parser)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
return _Run(args, holder)
name,
description,
facilityProvider
)
""")
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = client.MESSAGES_MODULE
project = properties.VALUES.core.project.GetOrFail()
args.filter, filter_expr = filter_rewrite.Rewriter().Rewrite(args.filter)
request = messages.ComputeInterconnectLocationsListRequest(
project=project, filter=filter_expr)
results = list_pager.YieldFromList(
client.interconnectLocations,
request,
field='items',
limit=args.limit,
batch_size=None)
for item in results:
yield item
List.detailed_help = base_classes.GetGlobalListerHelp('interconnect locations')
from googlecloudsdk.api_lib.compute import lister
from googlecloudsdk.calliope import base
class List(base.ListCommand):
"""List Google Compute Engine snapshots."""
@staticmethod
def Args(parser):
parser.display_info.AddFormat("""\
table(
name,
diskSizeGb,
sourceDisk.scope():label=SRC_DISK,
status
)""")
lister.AddBaseListerArgs(parser)
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.snapshots)
return lister.Invoke(request_data, list_implementation)
List.detailed_help = base_classes.GetGlobalListerHelp('snapshots')
from googlecloudsdk.api_lib.compute import base_classes
from googlecloudsdk.api_lib.compute import lister
from googlecloudsdk.api_lib.compute import networks_utils
from googlecloudsdk.calliope import base
from googlecloudsdk.command_lib.compute.networks import flags
class List(base.ListCommand):
"""List Google Compute Engine networks."""
@staticmethod
def Args(parser):
lister.AddBaseListerArgs(parser)
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
parser.display_info.AddCacheUpdater(flags.NetworksCompleter)
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))
List.detailed_help = base_classes.GetGlobalListerHelp('networks')
from googlecloudsdk.api_lib.compute import base_classes
from googlecloudsdk.calliope import base
from googlecloudsdk.core import properties
class List(base.ListCommand):
"""List security policies."""
@staticmethod
def Args(parser):
parser.display_info.AddFormat('table(name)')
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = client.MESSAGES_MODULE
project = properties.VALUES.core.project.Get(required=True)
request = messages.ComputeSecurityPoliciesListRequest(
project=project, filter=args.filter)
return list_pager.YieldFromList(client.securityPolicies,
request,
field='items',
limit=args.limit,
batch_size=None)
List.detailed_help = base_classes.GetGlobalListerHelp('security policies')
lister.AddBaseListerArgs(parser)
parser.display_info.AddCacheUpdater(flags.TargetHttpProxiesCompleter)
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.targetHttpProxies)
return lister.Invoke(request_data, list_implementation)
List.detailed_help = base_classes.GetGlobalListerHelp('target HTTP proxies')
@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
filter_expr = self.GetFilterExpr(args)
image_projects = [self.project]
if args.standard_images:
image_projects.extend(constants.PUBLIC_IMAGE_PROJECTS)
if args.preview_images:
image_projects.extend(constants.PREVIEW_IMAGE_PROJECTS)
requests = []
for project in image_projects:
requests.append((self.service, 'List',
self.messages.ComputeImagesListRequest(
filter=filter_expr,
maxResults=constants.MAX_RESULTS_PER_PAGE,
project=project)))
images = request_helper.MakeRequests(requests=requests,
http=self.http,
batch_url=self.batch_url,
errors=errors,
custom_get_requests=None)
for image in images:
if not image.deprecated or args.show_deprecated:
yield image
List.detailed_help = base_classes.GetGlobalListerHelp('images')
'EXAMPLES':
"""\
To list all external VPN gateways, run:
$ {command}"""
}
@staticmethod
def Args(parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
def Run(self, args):
"""Issues the request to list all external VPN gateways."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = client.MESSAGES_MODULE
project = properties.VALUES.core.project.Get(required=True)
request = messages.ComputeExternalVpnGatewaysListRequest(
project=project, filter=args.filter)
return list_pager.YieldFromList(client.externalVpnGateways,
request,
field='items',
limit=args.limit,
batch_size=None)
List.detailed_help = base_classes.GetGlobalListerHelp('external VPN gateways')
RESOURCE_TYPE = 'firewall rules'
@base.ReleaseTracks(base.ReleaseTrack.GA)
class List(base_classes.GlobalLister):
"""List Google Compute Engine firewall rules."""
@property
def service(self):
return self.compute.firewalls
@property
def resource_type(self):
return 'firewalls'
List.detailed_help = base_classes.GetGlobalListerHelp(RESOURCE_TYPE)
DETAILED_HELP = {
'brief':
'List Google Compute Engine ' + RESOURCE_TYPE,
'DESCRIPTION':
"""\
*{{command}}* displays all Google Compute Engine {0} in a project.
""".format(RESOURCE_TYPE)
}
EXAMPLE_FORMAT = """\
To list all {0} in a project in table form, run:
$ {{command}}
lister.AddBaseListerArgs(parser)
parser.display_info.AddCacheUpdater(flags.SslCertificatesCompleter)
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.sslCertificates)
return lister.Invoke(request_data, list_implementation)
List.detailed_help = base_classes.GetGlobalListerHelp('SSL certificates')
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
class ListAlpha(base.ListCommand):
"""List Google Compute Engine SSL certificates."""
@classmethod
def Args(cls, parser):
parser.display_info.AddFormat(flags.ALPHA_LIST_FORMAT)
lister.AddMultiScopeListerFlags(parser, regional=True, global_=True)
parser.display_info.AddCacheUpdater(
flags.SslCertificatesCompleterAlpha)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
@staticmethod
def Args(parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
lister.AddBaseListerArgs(parser)
def Run(self, args):
compute_holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
cua_holder = base_classes.ComputeUserAccountsApiHolder(self.ReleaseTrack())
compute_client = compute_holder.client
cua_client = cua_holder.client
request_data = lister.ParseNamesAndRegexpFlags(args,
compute_holder.resources)
errors = []
for item in lister.GetGlobalResourcesDicts(
service=cua_client.groups,
project=list(request_data.scope_set)[0].project,
filter_expr=request_data.filter,
http=compute_client.apitools_client.http,
batch_url='https://www.googleapis.com/batch/',
errors=errors):
yield item
if errors:
utils.RaiseToolException(errors)
List.detailed_help = base_classes.GetGlobalListerHelp('groups')
from googlecloudsdk.core import log
@base.ReleaseTracks(base.ReleaseTrack.GA, base.ReleaseTrack.BETA)
class List(base_classes.GlobalLister):
"""List Google Compute Engine firewall rules."""
@property
def service(self):
return self.compute.firewalls
@property
def resource_type(self):
return 'firewalls'
List.detailed_help = base_classes.GetGlobalListerHelp('firewall rules')
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
class ListAlpha(List):
"""List Google Compute Engine firewall rules."""
def Run(self, args):
log.status.Print(flags.LIST_NOTICE)
return super(ListAlpha, self).Run(args)
def Collection(self):
return 'compute.firewalls.alpha'
RESOURCE_TYPE = 'firewall rules'
# Copyright 2015 Google Inc. All Rights Reserved.
"""Command for listing users."""
from googlecloudsdk.api_lib.compute import base_classes
class List(base_classes.GlobalLister):
"""List Google Compute Engine users."""
@property
def service(self):
return self.clouduseraccounts.users
@property
def resource_type(self):
return 'users'
@property
def messages(self):
return self.clouduseraccounts.MESSAGES_MODULE
List.detailed_help = base_classes.GetGlobalListerHelp('users')
# Copyright 2014 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Command for listing regions."""
from googlecloudsdk.api_lib.compute import base_classes
class List(base_classes.GlobalLister):
"""List Google Compute Engine regions."""
@property
def service(self):
return self.compute.regions
@property
def resource_type(self):
return 'regions'
List.detailed_help = base_classes.GetGlobalListerHelp('regions')
# Copyright 2014 Google Inc. All Rights Reserved.
"""Command for listing backend services."""
from googlecloudsdk.api_lib.compute import base_classes
class List(base_classes.GlobalLister):
"""List backend services."""
@property
def service(self):
return self.compute.backendServices
@property
def resource_type(self):
return 'backendServices'
List.detailed_help = base_classes.GetGlobalListerHelp('backend services')
"""The service used to list regional resources."""
return None
@property
def aggregation_service(self):
"""The service used to get aggregated list of resources."""
return self.compute.healthChecks
def GetResources(self, args, errors):
health_checks = super(ListAlpha, self).GetResources(args, errors)
# If a protocol is specified, check that it is one we support, and convert
# it to a number.
protocol_value = None
if args.protocol is not None:
protocol_value = self._ConvertProtocolArgToValue(args)
if protocol_value not in self._ProtocolWhitelist():
# TODO(b/111311137): Replace with InvalidArgumentException.
raise exceptions.ToolException(
'Invalid health check protocol ' + args.protocol + '.')
for health_check in health_checks:
if (protocol_value is None
or health_check['type'] == args.protocol.upper()):
yield health_check
List.detailed_help = base_classes.GetGlobalListerHelp('health checks')
ListBeta.detailed_help = base_classes.GetGlobalListerHelp('health checks')
ListAlpha.detailed_help = base_classes.GetGlobalListerHelp('health checks')
lister.AddBaseListerArgs(parser)
parser.display_info.AddCacheUpdater(flags.UrlMapsCompleter)
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.urlMaps)
return lister.Invoke(request_data, list_implementation)
List.detailed_help = base_classes.GetGlobalListerHelp('URL maps')
@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
"""Command for listing backend buckets."""
from googlecloudsdk.api_lib.compute import base_classes
from googlecloudsdk.api_lib.compute import lister
from googlecloudsdk.calliope import base
from googlecloudsdk.command_lib.compute import completers
from googlecloudsdk.command_lib.compute.backend_buckets import flags
class List(base.ListCommand):
"""List backend buckets."""
@staticmethod
def Args(parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
lister.AddBaseListerArgs(parser)
parser.display_info.AddCacheUpdater(completers.InstancesCompleter)
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.backendBuckets)
return lister.Invoke(request_data, list_implementation)
List.detailed_help = base_classes.GetGlobalListerHelp('backend buckets')
"""Lists Compute Engine public delegated prefixes."""
@staticmethod
def Args(parser):
parser.display_info.AddFormat("""\
table(
name,
selfLink.scope().segment(-3).yesno(no="global"):label=LOCATION,
parentPrefix.basename():label=PARENT_PREFIX,
ipCidrRange:label=RANGE,
status
)""")
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)
List.detailed_help = base_classes.GetGlobalListerHelp(
'public delegated prefixes')
from googlecloudsdk.api_lib.compute import base_classes
from googlecloudsdk.api_lib.compute import lister
from googlecloudsdk.calliope import base
from googlecloudsdk.command_lib.compute import completers
from googlecloudsdk.command_lib.compute.https_health_checks import flags
class List(base.ListCommand):
"""List HTTPS health checks."""
@staticmethod
def Args(parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
lister.AddBaseListerArgs(parser)
parser.display_info.AddCacheUpdater(
completers.HttpsHealthChecksCompleter)
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)
List.detailed_help = base_classes.GetGlobalListerHelp('HTTPS health checks')
synthesized_network = resource_projector.MakeSerializable(network)
for peering in synthesized_network['peerings']:
peering['source_network'] = network.selfLink
yield synthesized_network
@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
class ListAlpha(List):
"""List Google Compute Engine network peerings."""
@staticmethod
def Args(parser):
parser.display_info.AddFormat("""
table(peerings:format="table(
name,
source_network.basename():label=NETWORK,
network.map().scope(projects).segment(0):label=PEER_PROJECT,
network.basename():label=PEER_NETWORK,
autoCreateRoutes,
importCustomRoutes,
exportCustomRoutes,
state,
stateDetails
)")
""")
parser.add_argument(
'--network', help='Only show peerings of a specific network.')
List.detailed_help = base_classes.GetGlobalListerHelp('peerings')
from googlecloudsdk.core import properties
class List(base.ListCommand):
"""List Google Compute Engine SSL policies."""
@staticmethod
def Args(parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
def Run(self, args):
"""Issues the request to list all SSL policies."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = client.MESSAGES_MODULE
project = properties.VALUES.core.project.Get(required=True)
request = messages.ComputeSslPoliciesListRequest(
project=project, filter=args.filter)
return list_pager.YieldFromList(
client.sslPolicies,
request,
field='items',
limit=args.limit,
batch_size=None)
List.detailed_help = base_classes.GetGlobalListerHelp('SSL policies')
from googlecloudsdk.calliope import base
class List(base.ListCommand):
"""Lists Google Compute Engine public advertised prefixes."""
@staticmethod
def Args(parser):
parser.display_info.AddFormat("""\
table(
name,
ipCidrRange:label=RANGE,
dnsVerificationIp,
status
)""")
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)
List.detailed_help = base_classes.GetGlobalListerHelp(
'public advertised prefixes')
