text: # -*- coding: utf-8 -*- #
  # Copyright 2017 Google LLC. 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 available services."""
  
  from __future__ import absolute_import
  from __future__ import division
  from __future__ import unicode_literals
  
  from googlecloudsdk.api_lib.run import global_methods
  from googlecloudsdk.calliope import base
  from googlecloudsdk.command_lib.run import commands
  from googlecloudsdk.command_lib.run import connection_context
  from googlecloudsdk.command_lib.run import flags
  from googlecloudsdk.command_lib.run import pretty_print
  from googlecloudsdk.command_lib.run import resource_args
  from googlecloudsdk.command_lib.run import serverless_operations
  from googlecloudsdk.command_lib.util.concepts import concept_parsers
  from googlecloudsdk.command_lib.util.concepts import presentation_specs
  from googlecloudsdk.core import log
  
  
  @base.ReleaseTracks(base.ReleaseTrack.BETA)
  class List(commands.List):
    """List available services."""
  
    detailed_help = {
        'DESCRIPTION': """\
            {description}
            """,
        'EXAMPLES': """\
            To list available services:
  
                $ {command}
            """,
    }
  
    @classmethod
    def CommonArgs(cls, parser):
      # Flags specific to managed CR
      managed_group = flags.GetManagedArgGroup(parser)
      concept_parsers.ConceptParser([
          resource_args.CLOUD_RUN_LOCATION_PRESENTATION
      ]).AddToParser(managed_group)
      # Flags specific to CRoGKE
      gke_group = flags.GetGkeArgGroup(parser)
      namespace_presentation = presentation_specs.ResourcePresentationSpec(
          '--namespace',
          resource_args.GetNamespaceResourceSpec(),
          'Namespace list services in.',
          required=True,
          prefixes=False)
      concept_parsers.ConceptParser(
          [resource_args.CLUSTER_PRESENTATION,
           namespace_presentation]).AddToParser(gke_group)
      parser.display_info.AddUriFunc(cls._GetResourceUri)
  
    @classmethod
    def Args(cls, parser):
      cls.CommonArgs(parser)
      # Flags not specific to any platform
      flags.AddPlatformArg(parser)
  
    def _SetFormat(self, args, show_region=False, show_namespace=False):
      """Set display format for output.
  
      Args:
        args: Namespace, the args namespace
        show_region: bool, True to show region of listed services
        show_namespace: bool, True to show namespace of listed services
      """
      columns = [
          pretty_print.READY_COLUMN,
          'firstof(id,metadata.name):label=SERVICE',
      ]
      if show_region:
        columns.append('region:label=REGION')
      if show_namespace:
        columns.append('namespace:label=NAMESPACE')
      columns.extend([
          'domain:label=URL',
          'last_modifier:label="LAST DEPLOYED BY"',
          'last_transition_time:label="LAST DEPLOYED AT"',
      ])
      args.GetDisplayInfo().AddFormat(
          'table({})'.format(','.join(columns)))
  
    def Run(self, args):
      """List available services."""
      is_managed = flags.IsManaged(args)
      if is_managed and not getattr(args, 'region', None):
        self._SetFormat(args, show_region=True)
        client = global_methods.GetServerlessClientInstance()
        self.SetPartialApiEndpoint(client.url)
        args.CONCEPTS.namespace.Parse()  # Error if no proj.
        locations_ref = args.CONCEPTS.region.Parse()
        return commands.SortByName(
            global_methods.ListServices(client, locations_ref.RelativeName()))
      else:
        conn_context = connection_context.GetConnectionContext(args)
        self._SetFormat(
            args, show_region=is_managed, show_namespace=(not is_managed))
        namespace_ref = args.CONCEPTS.namespace.Parse()
        with serverless_operations.Connect(conn_context) as client:
          self.SetCompleteApiEndpoint(conn_context.endpoint)
          if not is_managed:
            location_msg = ' in [{}]'.format(conn_context.cluster_location)
            log.status.Print('For cluster [{cluster}]{zone}:'.format(
                cluster=conn_context.cluster_name,
                zone=location_msg if conn_context.cluster_location else ''))
          return commands.SortByName(client.ListServices(namespace_ref))
  
  
  @base.ReleaseTracks(base.ReleaseTrack.ALPHA)
  class AlphaList(List):
    """List available services."""
  
    @classmethod
    def Args(cls, parser):
      cls.CommonArgs(parser)
      # Flags specific to connecting to a Kubernetes cluster (kubeconfig)
      kubernetes_group = flags.GetKubernetesArgGroup(parser)
      flags.AddKubeconfigFlags(kubernetes_group)
      # Flags not specific to any platform
      flags.AddAlphaPlatformArg(parser)
  
  AlphaList.__doc__ = List.__doc__
  