feat: Add new gcloud commands, API clients, and third-party libraries across various services.

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_https_proxies/__init__.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2014 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.
+"""Commands for reading and manipulating target HTTPS proxies."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.calliope import base
+
+
+@base.UniverseCompatible
+@base.ReleaseTracks(
+    base.ReleaseTrack.ALPHA, base.ReleaseTrack.BETA, base.ReleaseTrack.GA)
+class TargetHTTPSProxies(base.Group):
+  """List, create, and delete target HTTPS proxies."""
+
+
+TargetHTTPSProxies.category = base.NETWORKING_CATEGORY
+
+TargetHTTPSProxies.detailed_help = {
+    'DESCRIPTION': """
+        List, create, and delete target HTTPS proxies.
+
+        For more information about target HTTPS proxies, see the
+        [target HTTPS proxies documentation](https://cloud.google.com/load-balancing/docs/target-proxies).
+
+        See also: [Target HTTPS proxies API](https://cloud.google.com/compute/docs/reference/rest/v1/targetHttpsProxies)
+        and
+        [Regional target HTTPS proxies API](https://cloud.google.com/compute/docs/reference/rest/v1/regionTargetHttpsProxies).
+    """,
+}

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_https_proxies/config/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2021 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 group for managing Compute Engine target https proxy configurations."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.calliope import base
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class Config(base.Group):
+  """Manage Compute Engine target https proxy configurations."""

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_https_proxies/config/export.yaml

@@ -0,0 +1,38 @@
+release_tracks: [ALPHA]
+command_type: CONFIG_EXPORT
+help_text:
+  brief: Export the configuration for a Compute Engine target https proxy.
+  description: |
+    *{command}* exports the configuration for a Compute Engine target https proxy.
+
+    Target https proxy configurations can be exported in
+    Kubernetes Resource Model (krm) or Terraform HCL formats. The
+    default format is `krm`.
+
+    Specifying `--all` allows you to export the configurations for all
+    target https proxies within the project.
+
+    Specifying `--path` allows you to export the configuration(s) to
+    a local directory.
+  examples: |
+    To export the configuration for a target https proxy, run:
+
+      $ {command} my-target-https-proxy
+
+    To export the configuration for a target https proxy to a file, run:
+
+      $ {command} my-target-https-proxy --path=/path/to/dir/
+
+    To export the configuration for a target https proxy in Terraform
+    HCL format, run:
+
+      $ {command} my-target-https-proxy --resource-format=terraform
+
+    To export the configurations for all target https proxies within a
+    project, run:
+
+      $ {command} --all
+arguments:
+  resource:
+    help_text: Target https proxy to export the configuration for.
+    spec: !REF googlecloudsdk.command_lib.compute.resources:target_https_proxy

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_https_proxies/create.py

@@ -0,0 +1,279 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2014 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 creating target HTTPS proxies."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.api_lib.compute import base_classes
+from googlecloudsdk.api_lib.compute import target_proxies_utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.certificate_manager import resource_args as cm_resource_args
+from googlecloudsdk.command_lib.compute import reference_utils
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.ssl_certificates import flags as ssl_certificates_flags
+from googlecloudsdk.command_lib.compute.ssl_policies import flags as ssl_policies_flags
+from googlecloudsdk.command_lib.compute.target_https_proxies import flags
+from googlecloudsdk.command_lib.compute.target_https_proxies import target_https_proxies_utils
+from googlecloudsdk.command_lib.compute.url_maps import flags as url_map_flags
+from googlecloudsdk.command_lib.network_security import resource_args as ns_resource_args
+
+
+def _DetailedHelp():
+  return {
+      'brief': 'Create a target HTTPS proxy.',
+      'DESCRIPTION': """
+      *{command}* is used to create target HTTPS proxies. A target
+      HTTPS proxy is referenced by one or more forwarding rules which
+      specify the network traffic that the proxy is responsible for
+      routing. The target HTTPS proxy points to a URL map that defines
+      the rules for routing the requests. The URL map's job is to map
+      URLs to backend services which handle the actual requests. The
+      target HTTPS proxy also points to at most 15 SSL certificates
+      used for server-side authentication. The target HTTPS proxy can
+      be associated with at most one SSL policy.
+      """,
+      'EXAMPLES': """
+      If there is an already-created URL map with the name URL_MAP
+      and a SSL certificate named SSL_CERTIFICATE, create a
+      global target HTTPS proxy pointing to this map by running:
+
+        $ {command} PROXY_NAME --url-map=URL_MAP --ssl-certificates=SSL_CERTIFICATE
+
+      Create a regional target HTTPS proxy by running:
+
+        $ {command} PROXY_NAME --url-map=URL_MAP --ssl-certificates=SSL_CERTIFICATE --region=REGION_NAME
+      """,
+  }
+
+
+def _Args(
+    parser,
+    traffic_director_security=False,
+    list_format=None,
+):
+  """Add the target https proxies command line flags to the parser."""
+
+  parser.display_info.AddFormat(list_format)
+  parser.add_argument(
+      '--description',
+      help='An optional, textual description for the target HTTPS proxy.',
+  )
+
+  parser.display_info.AddCacheUpdater(flags.TargetHttpsProxiesCompleter)
+  target_proxies_utils.AddQuicOverrideCreateArgs(parser)
+  target_proxies_utils.AddTlsEarlyDataCreateArgs(parser)
+
+  if traffic_director_security:
+    flags.AddProxyBind(parser, False)
+
+  target_proxies_utils.AddHttpKeepAliveTimeoutSec(parser)
+
+  ns_resource_args.GetServerTlsPolicyResourceArg(
+      'to attach', name='server-tls-policy', region_fallthrough=True
+  ).AddToParser(parser)
+
+  cm_resource_args.AddCertificateMapResourceArg(
+      parser,
+      'to attach',
+      name='certificate-map',
+      positional=False,
+      required=False,
+      with_location=False,
+  )
+
+
+def _Run(
+    args,
+    holder,
+    proxy_ref,
+    url_map_ref,
+    ssl_certificates,
+    ssl_policy_ref,
+    traffic_director_security,
+    certificate_map_ref,
+    server_tls_policy_ref,
+):
+  """Issues requests necessary to create Target HTTPS Proxies."""
+  client = holder.client
+
+  if traffic_director_security and args.proxy_bind:
+    target_https_proxy = client.messages.TargetHttpsProxy(
+        description=args.description,
+        name=proxy_ref.Name(),
+        urlMap=url_map_ref.SelfLink(),
+        sslCertificates=ssl_certificates,
+        proxyBind=args.proxy_bind,
+    )
+  else:
+    target_https_proxy = client.messages.TargetHttpsProxy(
+        description=args.description,
+        name=proxy_ref.Name(),
+        urlMap=url_map_ref.SelfLink(),
+        sslCertificates=ssl_certificates,
+    )
+
+  if args.IsSpecified('http_keep_alive_timeout_sec'):
+    target_https_proxy.httpKeepAliveTimeoutSec = (
+        args.http_keep_alive_timeout_sec
+    )
+
+  if args.IsSpecified('quic_override'):
+    quic_enum = client.messages.TargetHttpsProxy.QuicOverrideValueValuesEnum
+    target_https_proxy.quicOverride = quic_enum(args.quic_override)
+
+  if args.tls_early_data:
+    tls_early_data_enum = (
+        client.messages.TargetHttpsProxy.TlsEarlyDataValueValuesEnum
+    )
+    target_https_proxy.tlsEarlyData = tls_early_data_enum(args.tls_early_data)
+
+  if ssl_policy_ref:
+    target_https_proxy.sslPolicy = ssl_policy_ref.SelfLink()
+
+  if server_tls_policy_ref:
+    target_https_proxy.serverTlsPolicy = server_tls_policy_ref.SelfLink()
+
+  if certificate_map_ref:
+    target_https_proxy.certificateMap = certificate_map_ref.SelfLink()
+
+  if target_https_proxies_utils.IsRegionalTargetHttpsProxiesRef(proxy_ref):
+    request = client.messages.ComputeRegionTargetHttpsProxiesInsertRequest(
+        project=proxy_ref.project,
+        region=proxy_ref.region,
+        targetHttpsProxy=target_https_proxy,
+    )
+    collection = client.apitools_client.regionTargetHttpsProxies
+  else:
+    request = client.messages.ComputeTargetHttpsProxiesInsertRequest(
+        project=proxy_ref.project, targetHttpsProxy=target_https_proxy
+    )
+    collection = client.apitools_client.targetHttpsProxies
+
+  return client.MakeRequests([(collection, 'Insert', request)])
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA)
+@base.UniverseCompatible
+class Create(base.CreateCommand):
+  """Create a target HTTPS proxy."""
+
+  _traffic_director_security = False
+  _list_format = flags.DEFAULT_LIST_FORMAT
+
+  SSL_CERTIFICATES_ARG = None
+  TARGET_HTTPS_PROXY_ARG = None
+  URL_MAP_ARG = None
+  SSL_POLICY_ARG = None
+  detailed_help = _DetailedHelp()
+
+  @classmethod
+  def Args(cls, parser):
+    certificate_group = parser.add_mutually_exclusive_group()
+    cls.SSL_CERTIFICATES_ARG = (
+        ssl_certificates_flags.SslCertificatesArgumentForOtherResource(
+            'target HTTPS proxy', required=False
+        )
+    )
+    cls.SSL_CERTIFICATES_ARG.AddArgument(
+        parser, mutex_group=certificate_group, cust_metavar='SSL_CERTIFICATE'
+    )
+    cm_resource_args.AddCertificateResourceArg(
+        parser,
+        'to attach',
+        noun='certificate-manager-certificates',
+        name='certificate-manager-certificates',
+        positional=False,
+        required=False,
+        plural=True,
+        group=certificate_group,
+        with_location=False,
+    )
+
+    cls.TARGET_HTTPS_PROXY_ARG = flags.TargetHttpsProxyArgument()
+    cls.TARGET_HTTPS_PROXY_ARG.AddArgument(parser, operation_type='create')
+
+    cls.URL_MAP_ARG = url_map_flags.UrlMapArgumentForTargetProxy(
+        proxy_type='HTTPS'
+    )
+    cls.URL_MAP_ARG.AddArgument(parser)
+
+    cls.SSL_POLICY_ARG = (
+        ssl_policies_flags.GetSslPolicyMultiScopeArgumentForOtherResource(
+            'HTTPS', required=False
+        )
+    )
+    cls.SSL_POLICY_ARG.AddArgument(parser)
+
+    _Args(
+        parser,
+        traffic_director_security=cls._traffic_director_security,
+        list_format=cls._list_format,
+    )
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    proxy_ref = self.TARGET_HTTPS_PROXY_ARG.ResolveAsResource(
+        args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL
+    )
+    url_map_ref = target_https_proxies_utils.ResolveTargetHttpsProxyUrlMap(
+        args, self.URL_MAP_ARG, proxy_ref, holder.resources
+    )
+    ssl_certificates = target_https_proxies_utils.ResolveSslCertificates(
+        args, self.SSL_CERTIFICATES_ARG, proxy_ref, holder.resources
+    )
+    location = target_https_proxies_utils.GetLocation(proxy_ref)
+    if ssl_certificates:
+      ssl_certificates = [ref.SelfLink() for ref in ssl_certificates]
+    elif args.certificate_manager_certificates:
+      ssl_certificates = [
+          reference_utils.BuildCcmCertificateUrl(
+              proxy_ref.project, location, certificate_name
+          )
+          for certificate_name in args.certificate_manager_certificates
+      ]
+    if args.ssl_policy:
+      ssl_policy_ref = target_https_proxies_utils.ResolveSslPolicy(
+          args, self.SSL_POLICY_ARG, proxy_ref, holder.resources
+      )
+    else:
+      ssl_policy_ref = None
+    certificate_map_ref = args.CONCEPTS.certificate_map.Parse()
+
+    server_tls_policy_ref = None
+    if args.IsKnownAndSpecified('server_tls_policy'):
+      server_tls_policy_ref = args.CONCEPTS.server_tls_policy.Parse()
+    return _Run(
+        args,
+        holder,
+        proxy_ref,
+        url_map_ref,
+        ssl_certificates,
+        ssl_policy_ref,
+        self._traffic_director_security,
+        certificate_map_ref,
+        server_tls_policy_ref,
+    )
+
+
+@base.ReleaseTracks(base.ReleaseTrack.BETA)
+class CreateBeta(Create):
+  pass
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class CreateAlpha(CreateBeta):
+  _traffic_director_security = True

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_https_proxies/delete.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2014 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 deleting target HTTPS proxies."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.api_lib.compute import base_classes
+from googlecloudsdk.api_lib.compute import utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import flags as compute_flags
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.target_https_proxies import flags
+from googlecloudsdk.command_lib.compute.target_https_proxies import target_https_proxies_utils
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Delete target HTTPS proxies.',
+      'DESCRIPTION':
+          """\
+      *{command}* deletes one or more target HTTPS proxies.
+      """,
+      'EXAMPLES':
+          """\
+      Delete a global target HTTPS proxy by running:
+
+        $ {command} PROXY_NAME
+
+      Delete a regional target HTTPS proxy by running:
+
+        $ {command} PROXY_NAME --region=REGION_NAME
+      """,
+  }
+
+
+def _Run(args, holder, target_https_proxy_arg):
+  """Issues requests necessary to delete Target HTTPS Proxies."""
+  client = holder.client
+
+  target_https_proxy_refs = target_https_proxy_arg.ResolveAsResource(
+      args,
+      holder.resources,
+      default_scope=compute_scope.ScopeEnum.GLOBAL,
+      scope_lister=compute_flags.GetDefaultScopeLister(client))
+
+  utils.PromptForDeletion(target_https_proxy_refs)
+
+  requests = []
+  for target_https_proxy_ref in target_https_proxy_refs:
+    if target_https_proxies_utils.IsRegionalTargetHttpsProxiesRef(
+        target_https_proxy_ref):
+      requests.append(
+          (client.apitools_client.regionTargetHttpsProxies, 'Delete',
+           client.messages.ComputeRegionTargetHttpsProxiesDeleteRequest(
+               **target_https_proxy_ref.AsDict())))
+    else:
+      requests.append((client.apitools_client.targetHttpsProxies, 'Delete',
+                       client.messages.ComputeTargetHttpsProxiesDeleteRequest(
+                           **target_https_proxy_ref.AsDict())))
+
+  return client.MakeRequests(requests)
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA, base.ReleaseTrack.BETA,
+                    base.ReleaseTrack.GA)
+class Delete(base.DeleteCommand):
+  """Delete target HTTPS proxies."""
+
+  TARGET_HTTPS_PROXY_ARG = None
+  detailed_help = _DetailedHelp()
+
+  @classmethod
+  def Args(cls, parser):
+    cls.TARGET_HTTPS_PROXY_ARG = flags.TargetHttpsProxyArgument(plural=True)
+    cls.TARGET_HTTPS_PROXY_ARG.AddArgument(parser, operation_type='delete')
+    parser.display_info.AddCacheUpdater(flags.TargetHttpsProxiesCompleter)
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(args, holder, self.TARGET_HTTPS_PROXY_ARG)

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_https_proxies/describe.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2014 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 describing target HTTPS proxies."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.api_lib.compute import base_classes
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import flags as compute_flags
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.target_https_proxies import flags
+from googlecloudsdk.command_lib.compute.target_https_proxies import target_https_proxies_utils
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Display detailed information about a target HTTPS proxy.',
+      'DESCRIPTION':
+          """\
+      *{command}* displays all data associated with a target HTTPS proxy
+      in a project.
+      """,
+      'EXAMPLES':
+          """\
+      To describe a global target HTTPS proxy, run:
+
+        $ {command} PROXY_NAME
+
+      To describe a regional target HTTPS proxy, run:
+
+        $ {command} PROXY_NAME --region=REGION_NAME
+      """,
+  }
+
+
+def _Run(args, holder, target_https_proxy_arg):
+  """Issues requests necessary to describe Target HTTPS Proxies."""
+  client = holder.client
+
+  target_https_proxy_ref = target_https_proxy_arg.ResolveAsResource(
+      args,
+      holder.resources,
+      default_scope=compute_scope.ScopeEnum.GLOBAL,
+      scope_lister=compute_flags.GetDefaultScopeLister(client))
+
+  if target_https_proxies_utils.IsRegionalTargetHttpsProxiesRef(
+      target_https_proxy_ref):
+    request = client.messages.ComputeRegionTargetHttpsProxiesGetRequest(
+        **target_https_proxy_ref.AsDict())
+    collection = client.apitools_client.regionTargetHttpsProxies
+  else:
+    request = client.messages.ComputeTargetHttpsProxiesGetRequest(
+        **target_https_proxy_ref.AsDict())
+    collection = client.apitools_client.targetHttpsProxies
+
+  return client.MakeRequests([(collection, 'Get', request)])[0]
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA, base.ReleaseTrack.BETA,
+                    base.ReleaseTrack.GA)
+class Describe(base.DescribeCommand):
+  """Display detailed information about a target HTTPS proxy."""
+
+  TARGET_HTTPS_PROXY_ARG = None
+  detailed_help = _DetailedHelp()
+
+  @classmethod
+  def Args(cls, parser):
+    cls.TARGET_HTTPS_PROXY_ARG = flags.TargetHttpsProxyArgument()
+    cls.TARGET_HTTPS_PROXY_ARG.AddArgument(parser, operation_type='describe')
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(args, holder, self.TARGET_HTTPS_PROXY_ARG)

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_https_proxies/export.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2019 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.
+"""Export target HTTPS proxy command."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+import sys
+from googlecloudsdk.api_lib.compute import base_classes
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import flags as compute_flags
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.target_https_proxies import flags
+from googlecloudsdk.command_lib.compute.target_https_proxies import target_https_proxies_utils
+from googlecloudsdk.command_lib.export import util as export_util
+from googlecloudsdk.core.util import files
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Export a target HTTPS proxy.',
+      'DESCRIPTION':
+          """\
+          Exports a target HTTPS proxy's configuration to a file.
+          This configuration can be imported at a later time.
+          """,
+      'EXAMPLES':
+          """\
+          A target HTTPS proxy can be exported by running:
+
+            $ {command} NAME --destination=<path-to-file>
+          """
+  }
+
+
+def _GetApiVersion(release_track):
+  """Returns the API version based on the release track."""
+  if release_track == base.ReleaseTrack.ALPHA:
+    return 'alpha'
+  if release_track == base.ReleaseTrack.BETA:
+    return 'beta'
+  return 'v1'
+
+
+def _GetSchemaPath(release_track, for_help=False):
+  """Returns the resource schema path."""
+  return export_util.GetSchemaPath(
+      'compute',
+      _GetApiVersion(release_track),
+      'TargetHttpsProxy',
+      for_help=for_help)
+
+
+def _Run(args, holder, target_https_proxy_arg, release_track):
+  """Issues requests necessary to export target HTTPS proxies."""
+  client = holder.client
+
+  target_https_proxy_ref = target_https_proxy_arg.ResolveAsResource(
+      args,
+      holder.resources,
+      default_scope=compute_scope.ScopeEnum.GLOBAL,
+      scope_lister=compute_flags.GetDefaultScopeLister(client))
+
+  target_https_proxy = target_https_proxies_utils.SendGetRequest(
+      client, target_https_proxy_ref)
+
+  if args.destination:
+    with files.FileWriter(args.destination) as stream:
+      export_util.Export(
+          message=target_https_proxy,
+          stream=stream,
+          schema_path=_GetSchemaPath(release_track))
+  else:
+    export_util.Export(
+        message=target_https_proxy,
+        stream=sys.stdout,
+        schema_path=_GetSchemaPath(release_track))
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA, base.ReleaseTrack.BETA,
+                    base.ReleaseTrack.ALPHA)
+class Export(base.Command):
+  """Export a target HTTPS proxy."""
+
+  detailed_help = _DetailedHelp()
+  TARGET_HTTPS_PROXY_ARG = None
+
+  @classmethod
+  def Args(cls, parser):
+    cls.TARGET_HTTPS_PROXY_ARG = flags.TargetHttpsProxyArgument()
+    cls.TARGET_HTTPS_PROXY_ARG.AddArgument(parser, operation_type='export')
+    export_util.AddExportFlags(
+        parser, _GetSchemaPath(cls.ReleaseTrack(), for_help=True))
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(args, holder, self.TARGET_HTTPS_PROXY_ARG, self.ReleaseTrack())

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_https_proxies/import.py

@@ -0,0 +1,228 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2020 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.
+"""Import target HTTPS Proxies command."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from apitools.base.py import exceptions as apitools_exceptions
+from googlecloudsdk.api_lib.compute import base_classes
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import exceptions as compute_exceptions
+from googlecloudsdk.command_lib.compute import flags as compute_flags
+from googlecloudsdk.command_lib.compute import operation_utils
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.target_https_proxies import flags
+from googlecloudsdk.command_lib.compute.target_https_proxies import target_https_proxies_utils
+from googlecloudsdk.command_lib.export import util as export_util
+from googlecloudsdk.core import yaml_validator
+from googlecloudsdk.core.console import console_io
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Import a target HTTPS proxy.',
+      'DESCRIPTION':
+          """\
+          Imports a target HTTPS proxy's configuration from a file.
+          """,
+      'EXAMPLES':
+          """\
+          A global target HTTPS proxy can be imported by running:
+
+            $ {command} NAME --source=<path-to-file>
+
+          A regional target HTTPS proxy can be imported by running:
+
+            $ {command} NAME --source=<path-to-file> --region=REGION_NAME
+          """
+  }
+
+
+def _GetApiVersion(release_track):
+  """Returns the API version based on the release track."""
+  if release_track == base.ReleaseTrack.ALPHA:
+    return 'alpha'
+  elif release_track == base.ReleaseTrack.BETA:
+    return 'beta'
+  return 'v1'
+
+
+def _GetSchemaPath(release_track, for_help=False):
+  """Returns the resource schema path."""
+  return export_util.GetSchemaPath(
+      'compute',
+      _GetApiVersion(release_track),
+      'TargetHttpsProxy',
+      for_help=for_help)
+
+
+def _SendInsertRequest(client, resources, target_https_proxy_ref,
+                       target_https_proxy):
+  """Sends Target HTTPS Proxy insert request."""
+  if target_https_proxies_utils.IsRegionalTargetHttpsProxiesRef(
+      target_https_proxy_ref):
+    service = client.apitools_client.regionTargetHttpsProxies
+    operation = service.Insert(
+        client.messages.ComputeRegionTargetHttpsProxiesInsertRequest(
+            project=target_https_proxy_ref.project,
+            region=target_https_proxy_ref.region,
+            targetHttpsProxy=target_https_proxy))
+  else:
+    service = client.apitools_client.targetHttpsProxies
+    operation = service.Insert(
+        client.messages.ComputeTargetHttpsProxiesInsertRequest(
+            project=target_https_proxy_ref.project,
+            targetHttpsProxy=target_https_proxy))
+
+  return _WaitForOperation(resources, service, operation,
+                           target_https_proxy_ref, 'Inserting TargetHttpsProxy')
+
+
+def _SendPatchRequest(client, resources, target_https_proxy_ref,
+                      target_https_proxy):
+  """Make target HTTP proxy patch request."""
+  if target_https_proxies_utils.IsRegionalTargetHttpsProxiesRef(
+      target_https_proxy_ref):
+    service = client.apitools_client.regionTargetHttpsProxies
+    operation = service.Patch(
+        client.messages.ComputeRegionTargetHttpsProxiesPatchRequest(
+            project=target_https_proxy_ref.project,
+            region=target_https_proxy_ref.region,
+            targetHttpsProxy=target_https_proxy_ref.Name(),
+            targetHttpsProxyResource=target_https_proxy))
+  else:
+    service = client.apitools_client.targetHttpsProxies
+    operation = service.Patch(
+        client.messages.ComputeTargetHttpsProxiesPatchRequest(
+            project=target_https_proxy_ref.project,
+            targetHttpsProxy=target_https_proxy_ref.Name(),
+            targetHttpsProxyResource=target_https_proxy))
+
+  return _WaitForOperation(resources, service, operation,
+                           target_https_proxy_ref, 'Updating TargetHttpsProxy')
+
+
+def _WaitForOperation(resources, service, operation, target_https_proxy_ref,
+                      message):
+  """Waits for the TargetHttpsProxy operation to finish."""
+  if target_https_proxies_utils.IsRegionalTargetHttpsProxiesRef(
+      target_https_proxy_ref):
+    collection = operation_utils.GetRegionalOperationsCollection()
+  else:
+    collection = operation_utils.GetGlobalOperationsCollection()
+
+  return operation_utils.WaitForOperation(resources, service, operation,
+                                          collection, target_https_proxy_ref,
+                                          message)
+
+
+def _Run(args, holder, target_https_proxy_arg, release_track):
+  """Issues requests necessary to import target HTTPS proxies."""
+  client = holder.client
+  resources = holder.resources
+
+  target_https_proxy_ref = target_https_proxy_arg.ResolveAsResource(
+      args,
+      holder.resources,
+      default_scope=compute_scope.ScopeEnum.GLOBAL,
+      scope_lister=compute_flags.GetDefaultScopeLister(client))
+
+  data = console_io.ReadFromFileOrStdin(args.source or '-', binary=False)
+
+  try:
+    target_https_proxy = export_util.Import(
+        message_type=client.messages.TargetHttpsProxy,
+        stream=data,
+        schema_path=_GetSchemaPath(release_track))
+  except yaml_validator.ValidationError as e:
+    raise compute_exceptions.ValidationError(str(e))
+
+  # Get existing target HTTPS proxy.
+  try:
+    old_target_https_proxy = target_https_proxies_utils.SendGetRequest(
+        client, target_https_proxy_ref)
+  except apitools_exceptions.HttpError as error:
+    if error.status_code != 404:
+      raise error
+    # Target HTTPS proxy does not exist, create a new one.
+    return _SendInsertRequest(client, resources, target_https_proxy_ref,
+                              target_https_proxy)
+
+  if old_target_https_proxy == target_https_proxy:
+    return
+
+  console_io.PromptContinue(
+      message=('Target Https Proxy [{0}] will be overwritten.').format(
+          target_https_proxy_ref.Name()),
+      cancel_on_no=True)
+
+  # Populate id and fingerprint fields. These two fields are manually
+  # removed from the schema files.
+  target_https_proxy.id = old_target_https_proxy.id
+
+  if hasattr(old_target_https_proxy, 'fingerprint'):
+    target_https_proxy.fingerprint = old_target_https_proxy.fingerprint
+
+  # Unspecified fields are assumed to be cleared.
+  cleared_fields = []
+  if target_https_proxy.description is None:
+    cleared_fields.append('description')
+  if target_https_proxy.serverTlsPolicy is None:
+    cleared_fields.append('serverTlsPolicy')
+  if target_https_proxy.authorizationPolicy is None:
+    cleared_fields.append('authorizationPolicy')
+  if hasattr(target_https_proxy,
+             'certificateMap') and target_https_proxy.certificateMap is None:
+    cleared_fields.append('certificateMap')
+  if hasattr(target_https_proxy,
+             'httpFilters') and not target_https_proxy.httpFilters:
+    cleared_fields.append('httpFilters')
+  if target_https_proxy.proxyBind is None:
+    cleared_fields.append('proxyBind')
+  if target_https_proxy.quicOverride is None:
+    cleared_fields.append('quicOverride')
+  if not target_https_proxy.sslCertificates:
+    cleared_fields.append('sslCertificates')
+  if target_https_proxy.sslPolicy is None:
+    cleared_fields.append('sslPolicy')
+  if target_https_proxy.urlMap is None:
+    cleared_fields.append('urlMap')
+
+  with client.apitools_client.IncludeFields(cleared_fields):
+    return _SendPatchRequest(client, resources, target_https_proxy_ref,
+                             target_https_proxy)
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA, base.ReleaseTrack.BETA,
+                    base.ReleaseTrack.ALPHA)
+class Import(base.UpdateCommand):
+  """Import a target HTTPS Proxy."""
+
+  detailed_help = _DetailedHelp()
+  TARGET_HTTPS_PROXY_ARG = None
+
+  @classmethod
+  def Args(cls, parser):
+    cls.TARGET_HTTPS_PROXY_ARG = flags.TargetHttpsProxyArgument()
+    cls.TARGET_HTTPS_PROXY_ARG.AddArgument(parser, operation_type='import')
+    export_util.AddImportFlags(
+        parser, _GetSchemaPath(cls.ReleaseTrack(), for_help=True))
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(args, holder, self.TARGET_HTTPS_PROXY_ARG, self.ReleaseTrack())

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_https_proxies/list.py

@@ -0,0 +1,68 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2014 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 target HTTPS proxies."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+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.target_https_proxies import flags
+
+
+def _DetailedHelp():
+  return base_classes.GetMultiScopeListerHelp(
+      'target HTTPS proxies',
+      scopes=[
+          base_classes.ScopeType.global_scope,
+          base_classes.ScopeType.regional_scope
+      ])
+
+
+def _Args(parser):
+  parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
+  parser.display_info.AddCacheUpdater(flags.TargetHttpsProxiesCompleter)
+  lister.AddMultiScopeListerFlags(parser, regional=True, global_=True)
+
+
+def _Run(args, holder):
+  """Issues requests necessary to list Target HTTPS Proxies."""
+  client = holder.client
+  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 lister.Invoke(request_data, list_implementation)
+
+
+@base.ReleaseTracks(base.ReleaseTrack.BETA, base.ReleaseTrack.GA,
+                    base.ReleaseTrack.ALPHA)
+class List(base.ListCommand):
+  """List target HTTPS proxies."""
+
+  detailed_help = _DetailedHelp()
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(parser)
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(args, holder)

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_https_proxies/update.py

@@ -0,0 +1,373 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2014 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 updating target HTTPS proxies."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from apitools.base.py import encoding
+from googlecloudsdk.api_lib.compute import base_classes
+from googlecloudsdk.api_lib.compute import target_proxies_utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.certificate_manager import resource_args
+from googlecloudsdk.command_lib.compute import exceptions as compute_exceptions
+from googlecloudsdk.command_lib.compute import flags as compute_flags
+from googlecloudsdk.command_lib.compute import reference_utils
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.ssl_certificates import flags as ssl_certificates_flags
+from googlecloudsdk.command_lib.compute.ssl_policies import flags as ssl_policies_flags
+from googlecloudsdk.command_lib.compute.target_https_proxies import flags
+from googlecloudsdk.command_lib.compute.target_https_proxies import target_https_proxies_utils
+from googlecloudsdk.command_lib.compute.url_maps import flags as url_map_flags
+from googlecloudsdk.command_lib.network_security import resource_args as ns_resource_args
+
+
+def _DetailedHelp():
+  return {
+      'brief': 'Update a target HTTPS proxy.',
+      'DESCRIPTION': """
+      *{command}* is used to change the SSL certificate and/or URL map of
+      existing target HTTPS proxies. A target HTTPS proxy is referenced by
+      one or more forwarding rules which specify the network traffic that
+      the proxy is responsible for routing. The target HTTPS proxy in turn
+      points to a URL map that defines the rules for routing the requests.
+      The URL map's job is to map URLs to backend services which handle
+      the actual requests. The target HTTPS proxy also points to at most
+      15 SSL certificates used for server-side authentication. The target
+      HTTPS proxy can be associated with at most one SSL policy.
+      """,
+      'EXAMPLES': """
+      Update the URL map of a global target HTTPS proxy by running:
+
+        $ {command} PROXY_NAME --url-map=URL_MAP
+
+      Update the SSL certificate of a global target HTTPS proxy by running:
+
+        $ {command} PROXY_NAME --ssl-certificates=SSL_CERTIFIFCATE
+
+      Update the URL map of a global target HTTPS proxy by running:
+
+        $ {command} PROXY_NAME --url-map=URL_MAP --region=REGION_NAME
+
+      Update the SSL certificate of a global target HTTPS proxy by running:
+
+        $ {command} PROXY_NAME --ssl-certificates=SSL_CERTIFIFCATE --region=REGION_NAME
+      """,
+  }
+
+
+def _CheckMissingArgument(args):
+  """Checks for missing argument."""
+  tls_early_data_args = ['tls_early_data']
+  all_args = [
+      'ssl_certificates',
+      'url_map',
+      'quic_override',
+      'ssl_policy',
+      'clear_ssl_policy',
+      'certificate_map',
+      'clear_certificate_map',
+      'clear_ssl_certificates',
+      'certificate_manager_certificates',
+      'clear_http_keep_alive_timeout_sec',
+      'http_keep_alive_timeout_sec',
+      'clear_server_tls_policy',
+      'server_tls_policy',
+  ] + (tls_early_data_args)
+  err_tls_early_data_args = ['[--tls-early-data]']
+  err_msg_args = [
+      '[--ssl-certificates]',
+      '[--url-map]',
+      '[--quic-override]',
+      '[--ssl-policy]',
+      '[--clear-ssl-policy]',
+      '[--certificate-map]',
+      '[--clear-certificate-map]',
+      '[--clear-ssl-certificates]',
+      '[--certificate-manager-certificates]',
+      '[--clear-http-keep-alive-timeout-sec]',
+      '[--http-keep-alive-timeout-sec]',
+      '[--clear-server-tls-policy]',
+      '[--server-tls-policy]',
+  ] + (err_tls_early_data_args)
+  if not sum(args.IsSpecified(arg) for arg in all_args):
+    raise compute_exceptions.ArgumentError(
+        'You must specify at least one of %s or %s.'
+        % (', '.join(err_msg_args[:-1]), err_msg_args[-1])
+    )
+
+
+def _Run(
+    args,
+    holder,
+    ssl_certificates_arg,
+    target_https_proxy_arg,
+    url_map_arg,
+    ssl_policy_arg,
+    certificate_map_ref,
+):
+  """Issues requests necessary to update Target HTTPS Proxies."""
+  client = holder.client
+
+  proxy_ref = target_https_proxy_arg.ResolveAsResource(
+      args,
+      holder.resources,
+      default_scope=compute_scope.ScopeEnum.GLOBAL,
+      scope_lister=compute_flags.GetDefaultScopeLister(client),
+  )
+
+  old_resource = _GetTargetHttpsProxy(client, proxy_ref)
+  new_resource = encoding.CopyProtoMessage(old_resource)
+  cleared_fields = []
+
+  clear_ssl_certificates = args.IsKnownAndSpecified('clear_ssl_certificates')
+  if args.ssl_certificates or clear_ssl_certificates:
+    new_resource.sslCertificates = []
+    if args.ssl_certificates:
+      ssl_cert_refs = target_https_proxies_utils.ResolveSslCertificates(
+          args, ssl_certificates_arg, proxy_ref, holder.resources
+      )
+      new_resource.sslCertificates = [ref.SelfLink() for ref in ssl_cert_refs]
+    if clear_ssl_certificates:
+      cleared_fields.append('sslCertificates')
+  elif args.certificate_manager_certificates:
+    location = target_https_proxies_utils.GetLocation(proxy_ref)
+    ssl_cert_refs = [
+        reference_utils.BuildCcmCertificateUrl(
+            proxy_ref.project, location, certificate_name
+        )
+        for certificate_name in args.certificate_manager_certificates
+    ]
+    new_resource.sslCertificates = ssl_cert_refs
+
+  if args.url_map:
+    new_resource.urlMap = (
+        target_https_proxies_utils.ResolveTargetHttpsProxyUrlMap(
+            args, url_map_arg, proxy_ref, holder.resources
+        ).SelfLink()
+    )
+
+  if args.quic_override:
+    new_resource.quicOverride = (
+        client.messages.TargetHttpsProxy.QuicOverrideValueValuesEnum(
+            args.quic_override
+        )
+    )
+
+  if args.tls_early_data:
+    new_resource.tlsEarlyData = (
+        client.messages.TargetHttpsProxy.TlsEarlyDataValueValuesEnum(
+            args.tls_early_data
+        )
+    )
+
+  if args.ssl_policy:
+    ssl_policy_ref = target_https_proxies_utils.ResolveSslPolicy(
+        args, ssl_policy_arg, proxy_ref, holder.resources
+    )
+    new_resource.sslPolicy = ssl_policy_ref.SelfLink()
+
+  if args.IsSpecified('clear_ssl_policy'):
+    new_resource.sslPolicy = None
+    cleared_fields.append('sslPolicy')
+
+  if args.IsSpecified('http_keep_alive_timeout_sec'):
+    new_resource.httpKeepAliveTimeoutSec = args.http_keep_alive_timeout_sec
+  elif args.IsSpecified('clear_http_keep_alive_timeout_sec'):
+    new_resource.httpKeepAliveTimeoutSec = None
+    cleared_fields.append('httpKeepAliveTimeoutSec')
+
+  if certificate_map_ref:
+    new_resource.certificateMap = certificate_map_ref.SelfLink()
+
+  if args.IsKnownAndSpecified('clear_certificate_map'):
+    new_resource.certificateMap = None
+    cleared_fields.append('certificateMap')
+
+  if args.IsKnownAndSpecified('server_tls_policy'):
+    server_tls_policy_ref = args.CONCEPTS.server_tls_policy.Parse()
+    new_resource.serverTlsPolicy = server_tls_policy_ref.SelfLink()
+  elif args.IsKnownAndSpecified('clear_server_tls_policy'):
+    new_resource.serverTlsPolicy = None
+    cleared_fields.append('serverTlsPolicy')
+
+  if old_resource != new_resource:
+    return _PatchTargetHttpsProxy(
+        client, proxy_ref, new_resource, cleared_fields
+    )
+  return []
+
+
+def _GetTargetHttpsProxy(client, proxy_ref):
+  """Retrieves the target HTTPS proxy."""
+  if target_https_proxies_utils.IsRegionalTargetHttpsProxiesRef(proxy_ref):
+    request = client.messages.ComputeRegionTargetHttpsProxiesGetRequest(
+        **proxy_ref.AsDict()
+    )
+    collection = client.apitools_client.regionTargetHttpsProxies
+  else:
+    request = client.messages.ComputeTargetHttpsProxiesGetRequest(
+        **proxy_ref.AsDict()
+    )
+    collection = client.apitools_client.targetHttpsProxies
+  return client.MakeRequests([(collection, 'Get', request)])[0]
+
+
+def _PatchTargetHttpsProxy(client, proxy_ref, new_resource, cleared_fields):
+  """Patches the target HTTPS proxy."""
+  requests = []
+  if target_https_proxies_utils.IsRegionalTargetHttpsProxiesRef(proxy_ref):
+    requests.append((
+        client.apitools_client.regionTargetHttpsProxies,
+        'Patch',
+        client.messages.ComputeRegionTargetHttpsProxiesPatchRequest(
+            project=proxy_ref.project,
+            region=proxy_ref.region,
+            targetHttpsProxy=proxy_ref.Name(),
+            targetHttpsProxyResource=new_resource,
+        ),
+    ))
+  else:
+    requests.append((
+        client.apitools_client.targetHttpsProxies,
+        'Patch',
+        client.messages.ComputeTargetHttpsProxiesPatchRequest(
+            project=proxy_ref.project,
+            targetHttpsProxy=proxy_ref.Name(),
+            targetHttpsProxyResource=new_resource,
+        ),
+    ))
+  with client.apitools_client.IncludeFields(cleared_fields):
+    return client.MakeRequests(requests)
+
+
+def _AddServerTLSPolicyArguments(parser):
+  """Adds all Server TLS Policy-related arguments."""
+  server_tls_group = parser.add_mutually_exclusive_group()
+  ns_resource_args.GetServerTlsPolicyResourceArg(
+      'to attach',
+      name='server-tls-policy',
+      group=server_tls_group,
+      region_fallthrough=True,
+  ).AddToParser(server_tls_group)
+  ns_resource_args.GetClearServerTLSPolicyForHttpsProxy().AddToParser(
+      server_tls_group
+  )
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA)
+@base.UniverseCompatible
+class Update(base.UpdateCommand):
+  """Update a target HTTPS proxy."""
+
+  SSL_CERTIFICATES_ARG = None
+  TARGET_HTTPS_PROXY_ARG = None
+  URL_MAP_ARG = None
+  SSL_POLICY_ARG = None
+  detailed_help = _DetailedHelp()
+
+  @classmethod
+  def Args(cls, parser):
+    cls.SSL_CERTIFICATES_ARG = (
+        ssl_certificates_flags.SslCertificatesArgumentForOtherResource(
+            'target HTTPS proxy', required=False
+        )
+    )
+
+    cls.TARGET_HTTPS_PROXY_ARG = flags.TargetHttpsProxyArgument()
+    cls.TARGET_HTTPS_PROXY_ARG.AddArgument(parser, operation_type='update')
+
+    cls.URL_MAP_ARG = url_map_flags.UrlMapArgumentForTargetProxy(
+        required=False, proxy_type='HTTPS'
+    )
+    cls.URL_MAP_ARG.AddArgument(parser)
+
+    group = parser.add_mutually_exclusive_group()
+    certificate_group = group.add_argument_group()
+    cert_main_flags_group = certificate_group.add_mutually_exclusive_group()
+    cls.SSL_CERTIFICATES_ARG.AddArgument(
+        certificate_group,
+        mutex_group=cert_main_flags_group,
+        cust_metavar='SSL_CERTIFICATE',
+    )
+    resource_args.AddCertificateResourceArg(
+        parser,
+        'to attach',
+        noun='certificate-manager-certificates',
+        name='certificate-manager-certificates',
+        positional=False,
+        required=False,
+        plural=True,
+        group=cert_main_flags_group,
+        with_location=False,
+    )
+    ssl_certificates_flags.GetClearSslCertificatesArgumentForOtherResource(
+        'HTTPS'
+    ).AddToParser(cert_main_flags_group)
+    map_group = group.add_mutually_exclusive_group()
+    resource_args.AddCertificateMapResourceArg(
+        map_group,
+        'to attach',
+        name='certificate-map',
+        positional=False,
+        required=False,
+        with_location=False,
+    )
+    resource_args.GetClearCertificateMapArgumentForOtherResource(
+        'HTTPS proxy'
+    ).AddToParser(map_group)
+
+    cls.SSL_POLICY_ARG = (
+        ssl_policies_flags.GetSslPolicyMultiScopeArgumentForOtherResource(
+            'HTTPS', required=False
+        )
+    )
+
+    group = parser.add_mutually_exclusive_group()
+    ssl_policy_group = group.add_argument_group()
+    cls.SSL_POLICY_ARG.AddArgument(ssl_policy_group)
+
+    ssl_policies_flags.GetClearSslPolicyArgumentForOtherResource(
+        'HTTPS', required=False
+    ).AddToParser(group)
+
+    group = parser.add_mutually_exclusive_group()
+    target_proxies_utils.AddHttpKeepAliveTimeoutSec(group)
+    target_proxies_utils.AddClearHttpKeepAliveTimeoutSec(group)
+
+    target_proxies_utils.AddQuicOverrideUpdateArgs(parser)
+    target_proxies_utils.AddTlsEarlyDataUpdateArgs(parser)
+
+    _AddServerTLSPolicyArguments(parser)
+
+  def Run(self, args):
+    _CheckMissingArgument(args)
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    certificate_map_ref = args.CONCEPTS.certificate_map.Parse()
+    return _Run(
+        args,
+        holder,
+        self.SSL_CERTIFICATES_ARG,
+        self.TARGET_HTTPS_PROXY_ARG,
+        self.URL_MAP_ARG,
+        self.SSL_POLICY_ARG,
+        certificate_map_ref,
+    )
+
+
+@base.ReleaseTracks(base.ReleaseTrack.BETA, base.ReleaseTrack.ALPHA)
+class UpdateBeta(Update):
+  pass