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_ssl_proxies/__init__.py

@@ -0,0 +1,43 @@
+# -*- 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 SSL 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 TargetSSLProxies(base.Group):
+  """List, create, and delete target SSL proxies."""
+
+
+TargetSSLProxies.category = base.NETWORKING_CATEGORY
+
+TargetSSLProxies.detailed_help = {
+    'DESCRIPTION': """
+        List, create, and delete target SSL target proxies for proxy Network
+        Load Balancers.
+
+        For more information about target SSL proxies, see the
+        [proxy Network Load Balancer documentation](https://cloud.google.com/load-balancing/docs/tcp/).
+
+        See also: [Target SSL proxies API](https://cloud.google.com/compute/docs/reference/rest/v1/targetSslProxies).
+    """,
+}

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_ssl_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 ssl 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 ssl proxy configurations."""

gcloud auth application-default login/google-cloud-sdk/lib/surface/compute/target_ssl_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 ssl proxy.
+  description: |
+    *{command}* exports the configuration for a Compute Engine target ssl proxy.
+
+    Target ssl 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 ssl 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 ssl proxy, run:
+
+      $ {command} my-target-ssl-proxy
+
+    To export the configuration for a target ssl proxy to a file, run:
+
+      $ {command} my-target-ssl-proxy --path=/path/to/dir/
+
+    To export the configuration for a target ssl proxy in Terraform
+    HCL format, run:
+
+      $ {command} my-target-ssl-proxy --resource-format=terraform
+
+    To export the configurations for all target ssl proxies within a
+    project, run:
+
+      $ {command} --all
+arguments:
+  resource:
+    help_text: Target ssl proxy to export the configuration for.
+    spec: !REF googlecloudsdk.command_lib.compute.resources:target_ssl_proxy

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

@@ -0,0 +1,153 @@
+# -*- 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 SSL 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.api_lib.compute import utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.certificate_manager import resource_args
+from googlecloudsdk.command_lib.compute.backend_services import (
+    flags as backend_service_flags)
+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_ssl_proxies import flags
+from googlecloudsdk.command_lib.compute.target_ssl_proxies import target_ssl_proxies_utils
+
+
+class Create(base.CreateCommand):
+  """Create a target SSL proxy.
+
+  *{command}* is used to create target SSL proxies. A target SSL proxy is
+  referenced by one or more forwarding rules which define which packets the
+  proxy is responsible for routing. The target SSL proxy points to a backend
+  service which handle the actual requests. The target SSL proxy also points
+  to at most 15 SSL certificates used for server-side authentication or one
+  certificate map. The target SSL proxy can be associated with at most one SSL
+  policy.
+  """
+
+  _certificate_map = True
+  _list_format = flags.DEFAULT_LIST_FORMAT
+
+  BACKEND_SERVICE_ARG = None
+  SSL_CERTIFICATES_ARG = None
+  TARGET_SSL_PROXY_ARG = None
+  SSL_POLICY_ARG = None
+
+  @classmethod
+  def Args(cls, parser):
+    target_proxies_utils.AddProxyHeaderRelatedCreateArgs(parser)
+
+    cls.BACKEND_SERVICE_ARG = (
+        backend_service_flags.BackendServiceArgumentForTargetSslProxy())
+    cls.BACKEND_SERVICE_ARG.AddArgument(parser)
+    cls.TARGET_SSL_PROXY_ARG = flags.TargetSslProxyArgument()
+    cls.TARGET_SSL_PROXY_ARG.AddArgument(parser, operation_type='create')
+
+    cls.SSL_CERTIFICATES_ARG = (
+        ssl_certificates_flags.SslCertificatesArgumentForOtherResource(
+            'target SSL proxy',
+            required=not cls._certificate_map,
+            include_regional_ssl_certificates=False))
+    if not cls._certificate_map:
+      cls.SSL_CERTIFICATES_ARG.AddArgument(
+          parser, cust_metavar='SSL_CERTIFICATE')
+
+    cls.SSL_POLICY_ARG = ssl_policies_flags.GetSslPolicyMultiScopeArgumentForOtherResource(
+        'SSL', required=False)
+    cls.SSL_POLICY_ARG.AddArgument(parser)
+
+    parser.add_argument(
+        '--description',
+        help='An optional, textual description for the target SSL proxy.')
+
+    parser.display_info.AddCacheUpdater(flags.TargetSslProxiesCompleter)
+    parser.display_info.AddFormat(cls._list_format)
+
+    if cls._certificate_map:
+      group = parser.add_argument_group(required=True)
+      cls.SSL_CERTIFICATES_ARG.AddArgument(
+          group, cust_metavar='SSL_CERTIFICATE')
+      resource_args.AddCertificateMapResourceArg(
+          group,
+          'to attach',
+          name='certificate-map',
+          positional=False,
+          required=False,
+          with_location=False)
+
+  def _CreateResource(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+
+    backend_service_ref = self.BACKEND_SERVICE_ARG.ResolveAsResource(
+        args, holder.resources)
+
+    target_ssl_proxy_ref = self.TARGET_SSL_PROXY_ARG.ResolveAsResource(
+        args, holder.resources)
+
+    ssl_cert_refs = None
+    if args.ssl_certificates:
+      ssl_cert_refs = self.SSL_CERTIFICATES_ARG.ResolveAsResource(
+          args, holder.resources)
+
+    client = holder.client.apitools_client
+    messages = holder.client.messages
+    if args.proxy_header:
+      proxy_header = messages.TargetSslProxy.ProxyHeaderValueValuesEnum(
+          args.proxy_header)
+    else:
+      proxy_header = (messages.TargetSslProxy.ProxyHeaderValueValuesEnum.NONE)
+
+    target_ssl_proxy = messages.TargetSslProxy(
+        description=args.description,
+        name=target_ssl_proxy_ref.Name(),
+        proxyHeader=proxy_header,
+        service=backend_service_ref.SelfLink())
+
+    if ssl_cert_refs:
+      target_ssl_proxy.sslCertificates = [
+          ref.SelfLink() for ref in ssl_cert_refs
+      ]
+
+    if args.ssl_policy:
+      target_ssl_proxy.sslPolicy = target_ssl_proxies_utils.ResolveSslPolicy(
+          args, self.SSL_POLICY_ARG, target_ssl_proxy_ref,
+          holder.resources).SelfLink()
+
+    if self._certificate_map:
+      certificate_map_ref = args.CONCEPTS.certificate_map.Parse()
+      if certificate_map_ref:
+        target_ssl_proxy.certificateMap = certificate_map_ref.SelfLink()
+
+    request = messages.ComputeTargetSslProxiesInsertRequest(
+        project=target_ssl_proxy_ref.project, targetSslProxy=target_ssl_proxy)
+
+    errors = []
+    resources = holder.client.MakeRequests(
+        [(client.targetSslProxies, 'Insert', request)], errors)
+
+    if errors:
+      utils.RaiseToolException(errors)
+    return resources
+
+  def Run(self, args):
+    return self._CreateResource(args)

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

@@ -0,0 +1,67 @@
+# -*- 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 SSL 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.target_ssl_proxies import flags
+
+
+class Delete(base.DeleteCommand):
+  """Delete target SSL proxy."""
+
+  TARGET_SSL_PROXY_ARG = None
+
+  @staticmethod
+  def Args(parser):
+    Delete.TARGET_SSL_PROXY_ARG = flags.TargetSslProxyArgument(plural=True)
+    Delete.TARGET_SSL_PROXY_ARG.AddArgument(parser, operation_type='delete')
+    parser.display_info.AddCacheUpdater(flags.TargetSslProxiesCompleter)
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    refs = self.TARGET_SSL_PROXY_ARG.ResolveAsResource(args, holder.resources)
+    utils.PromptForDeletion(refs)
+
+    client = holder.client.apitools_client
+    messages = holder.client.messages
+
+    requests = []
+    for ref in refs:
+      requests.append(
+          (client.targetSslProxies,
+           'Delete',
+           messages.ComputeTargetSslProxiesDeleteRequest(
+               project=ref.project, targetSslProxy=ref.Name())))
+
+    errors = []
+    resources = holder.client.MakeRequests(requests, errors)
+
+    if errors:
+      utils.RaiseToolException(errors)
+    return resources
+
+
+Delete.detailed_help = {
+    'brief': 'Delete target SSL proxies',
+    'DESCRIPTION': """\
+        *{command}* deletes one or more target SSL proxies.
+        """,
+}

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

@@ -0,0 +1,62 @@
+# -*- 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 SSL 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.target_ssl_proxies import flags
+
+
+class Describe(base.DescribeCommand):
+  """Display detailed information about a target SSL proxy."""
+
+  TARGET_SSL_PROXY_ARG = None
+
+  @staticmethod
+  def Args(parser):
+    Describe.TARGET_SSL_PROXY_ARG = flags.TargetSslProxyArgument()
+    Describe.TARGET_SSL_PROXY_ARG.AddArgument(parser, operation_type='describe')
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    ref = self.TARGET_SSL_PROXY_ARG.ResolveAsResource(args, holder.resources)
+
+    client = holder.client.apitools_client
+    messages = holder.client.messages
+
+    request = messages.ComputeTargetSslProxiesGetRequest(
+        project=ref.project, targetSslProxy=ref.Name())
+
+    errors = []
+    resources = holder.client.MakeRequests(
+        [(client.targetSslProxies, 'Get', request)], errors)
+
+    if errors:
+      utils.RaiseToolException(errors)
+    return resources[0]
+
+
+Describe.detailed_help = {
+    'brief': 'Display detailed information about a target SSL proxy',
+    'DESCRIPTION': """\
+        *{command}* displays all data associated with a target SSL proxy
+        in a project.
+        """,
+}

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

@@ -0,0 +1,54 @@
+# -*- 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 SSL proxies."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from apitools.base.py import list_pager
+from googlecloudsdk.api_lib.compute import base_classes
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute.target_ssl_proxies import flags
+from googlecloudsdk.core import properties
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA, base.ReleaseTrack.BETA,
+                    base.ReleaseTrack.ALPHA)
+class List(base.ListCommand):
+  """List target SSL proxies."""
+
+  @staticmethod
+  def Args(parser):
+    parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
+    parser.display_info.AddCacheUpdater(flags.TargetSslProxiesCompleter)
+
+  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.ComputeTargetSslProxiesListRequest(
+        project=project, filter=args.filter
+    )
+
+    return list_pager.YieldFromList(
+        client.targetSslProxies, request, field='items',
+        limit=args.limit, batch_size=None)
+
+List.detailed_help = base_classes.GetGlobalListerHelp('target SSL proxies')

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

@@ -0,0 +1,215 @@
+# -*- 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 SSL 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.api_lib.compute import 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.backend_services import (
+    flags as backend_service_flags)
+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_ssl_proxies import flags
+from googlecloudsdk.command_lib.compute.target_ssl_proxies import target_ssl_proxies_utils
+
+
+class Update(base.SilentCommand):
+  """Update a target SSL proxy.
+
+  *{command}* is used to replace the SSL certificate, backend service, proxy
+  header or SSL policy of existing target SSL proxies. A target SSL proxy is
+  referenced by one or more forwarding rules which define which packets the
+  proxy is responsible for routing. The target SSL proxy in turn points to a
+  backend service which will handle the requests. The target SSL proxy also
+  points to at most 15 SSL certificates used for server-side authentication
+  or one certificate map. The target SSL proxy can be associated with at most
+  one SSL policy.
+  """
+
+  _certificate_map = True
+
+  BACKEND_SERVICE_ARG = None
+  SSL_CERTIFICATES_ARG = None
+  TARGET_SSL_PROXY_ARG = None
+  SSL_POLICY_ARG = None
+
+  @classmethod
+  def Args(cls, parser):
+    target_proxies_utils.AddProxyHeaderRelatedUpdateArgs(parser)
+
+    cls.BACKEND_SERVICE_ARG = (
+        backend_service_flags.BackendServiceArgumentForTargetSslProxy(
+            required=False))
+    cls.BACKEND_SERVICE_ARG.AddArgument(parser)
+    cls.TARGET_SSL_PROXY_ARG = flags.TargetSslProxyArgument()
+    cls.TARGET_SSL_PROXY_ARG.AddArgument(parser, operation_type='update')
+    cls.SSL_CERTIFICATES_ARG = (
+        ssl_certificates_flags.SslCertificatesArgumentForOtherResource(
+            'target SSL proxy',
+            required=False,
+            include_regional_ssl_certificates=False))
+    if not cls._certificate_map:
+      cls.SSL_CERTIFICATES_ARG.AddArgument(
+          parser, cust_metavar='SSL_CERTIFICATE')
+
+    cls.SSL_POLICY_ARG = (
+        ssl_policies_flags.GetSslPolicyMultiScopeArgumentForOtherResource(
+            'SSL', 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(
+        'SSL', required=False).AddToParser(group)
+    if cls._certificate_map:
+      group = parser.add_mutually_exclusive_group(sort_args=False)
+      cls.SSL_CERTIFICATES_ARG.AddArgument(
+          group, cust_metavar='SSL_CERTIFICATE')
+      ssl_certificates_flags.GetClearSslCertificatesArgumentForOtherResource(
+          'SSL').AddToParser(group)
+      resource_args.AddCertificateMapResourceArg(
+          group,
+          'to attach',
+          name='certificate-map',
+          positional=False,
+          required=False,
+          with_location=False)
+      resource_args.GetClearCertificateMapArgumentForOtherResource(
+          'SSL proxy').AddToParser(group)
+
+  def _SendRequests(self,
+                    args,
+                    ssl_policy=None,
+                    clear_ssl_policy=False,
+                    certificate_map_ref=None):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    requests = []
+    target_ssl_proxy_ref = self.TARGET_SSL_PROXY_ARG.ResolveAsResource(
+        args, holder.resources)
+
+    client = holder.client.apitools_client
+    messages = holder.client.messages
+
+    clear_ssl_certificates = args.IsKnownAndSpecified('clear_ssl_certificates')
+    if args.ssl_certificates or clear_ssl_certificates:
+      ssl_certs = []
+      if args.ssl_certificates:
+        ssl_cert_refs = self.SSL_CERTIFICATES_ARG.ResolveAsResource(
+            args, holder.resources)
+        ssl_certs = [ref.SelfLink() for ref in ssl_cert_refs]
+      requests.append(
+          (client.targetSslProxies, 'SetSslCertificates',
+           messages.ComputeTargetSslProxiesSetSslCertificatesRequest(
+               project=target_ssl_proxy_ref.project,
+               targetSslProxy=target_ssl_proxy_ref.Name(),
+               targetSslProxiesSetSslCertificatesRequest=(
+                   messages.TargetSslProxiesSetSslCertificatesRequest(
+                       sslCertificates=ssl_certs)))))
+
+    if args.backend_service:
+      backend_service_ref = self.BACKEND_SERVICE_ARG.ResolveAsResource(
+          args, holder.resources)
+      requests.append(
+          (client.targetSslProxies, 'SetBackendService',
+           messages.ComputeTargetSslProxiesSetBackendServiceRequest(
+               project=target_ssl_proxy_ref.project,
+               targetSslProxy=target_ssl_proxy_ref.Name(),
+               targetSslProxiesSetBackendServiceRequest=(
+                   messages.TargetSslProxiesSetBackendServiceRequest(
+                       service=backend_service_ref.SelfLink())))))
+
+    if args.proxy_header:
+      proxy_header = (
+          messages.TargetSslProxiesSetProxyHeaderRequest
+          .ProxyHeaderValueValuesEnum(args.proxy_header))
+      requests.append((client.targetSslProxies, 'SetProxyHeader',
+                       messages.ComputeTargetSslProxiesSetProxyHeaderRequest(
+                           project=target_ssl_proxy_ref.project,
+                           targetSslProxy=target_ssl_proxy_ref.Name(),
+                           targetSslProxiesSetProxyHeaderRequest=(
+                               messages.TargetSslProxiesSetProxyHeaderRequest(
+                                   proxyHeader=proxy_header)))))
+    if args.ssl_policy:
+      ssl_policy_ref = target_ssl_proxies_utils.ResolveSslPolicy(
+          args, self.SSL_POLICY_ARG, target_ssl_proxy_ref, holder.resources)
+      ssl_policy = messages.SslPolicyReference(
+          sslPolicy=ssl_policy_ref.SelfLink())
+    else:
+      ssl_policy = None
+    clear_ssl_policy = args.clear_ssl_policy
+
+    if ssl_policy or clear_ssl_policy:
+      requests.append((client.targetSslProxies, 'SetSslPolicy',
+                       messages.ComputeTargetSslProxiesSetSslPolicyRequest(
+                           project=target_ssl_proxy_ref.project,
+                           targetSslProxy=target_ssl_proxy_ref.Name(),
+                           sslPolicyReference=ssl_policy)))
+
+    clear_certificate_map = args.IsKnownAndSpecified('clear_certificate_map')
+    certificate_map_ref = args.CONCEPTS.certificate_map.Parse(
+    ) if self._certificate_map else None
+    if certificate_map_ref or clear_certificate_map:
+      self_link = certificate_map_ref.SelfLink(
+      ) if certificate_map_ref else None
+      requests.append((client.targetSslProxies, 'SetCertificateMap',
+                       messages.ComputeTargetSslProxiesSetCertificateMapRequest(
+                           project=target_ssl_proxy_ref.project,
+                           targetSslProxy=target_ssl_proxy_ref.Name(),
+                           targetSslProxiesSetCertificateMapRequest=messages
+                           .TargetSslProxiesSetCertificateMapRequest(
+                               certificateMap=self_link))))
+
+    errors = []
+    resources = holder.client.MakeRequests(requests, errors)
+
+    if errors:
+      utils.RaiseToolException(errors)
+    return resources
+
+  def _CheckMissingArgument(self, args):
+    """Checks for missing argument."""
+    all_args = [
+        'ssl_certificates', 'proxy_header', 'backend_service', 'ssl_policy',
+        'clear_ssl_policy'
+    ]
+    err_msg_args = [
+        '[--ssl-certificates]', '[--backend-service]', '[--proxy-header]',
+        '[--ssl-policy]', '[--clear-ssl-policy]'
+    ]
+    if self._certificate_map:
+      all_args.append('certificate_map')
+      err_msg_args.append('[--certificate-map]')
+      all_args.append('clear_certificate_map')
+      err_msg_args.append('[--clear-certificate-map]')
+      all_args.append('clear_ssl_certificates')
+      err_msg_args.append('[--clear-ssl-certificates]')
+    if not sum(args.IsSpecified(arg) for arg in all_args):
+      raise compute_exceptions.UpdatePropertyError(
+          'You must specify at least one of %s or %s.' %
+          (', '.join(err_msg_args[:-1]), err_msg_args[-1]))
+
+  def Run(self, args):
+    self._CheckMissingArgument(args)
+    return self._SendRequests(args)