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

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2015 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 creating health checks."""
+
+from __future__ import absolute_import
+from __future__ import division
+from __future__ import unicode_literals
+
+from googlecloudsdk.calliope import base
+
+
+class HealthChecksCreate(base.Group):
+  """Create (non-legacy) health checks for load balanced instances."""
+
+
+HealthChecksCreate.detailed_help = {
+    'brief': ('Create (non-legacy) health checks for load balanced instances')
+}

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

@@ -0,0 +1,138 @@
+# -*- 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.
+"""Command for creating gRPC health checks."""
+
+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 health_checks_utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.calliope import exceptions
+from googlecloudsdk.command_lib.compute import completers
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.health_checks import flags
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Create a gRPC health check to monitor load balanced instances.',
+      'DESCRIPTION':
+          """\
+      *{command}* is used to create a non-legacy health check using the gRPC
+      protocol. You can use this health check for Google Cloud load
+      balancers or for managed instance group autohealing. For more information,
+      see the health checks overview at:
+      [](https://cloud.google.com/load-balancing/docs/health-check-concepts)
+      """,
+  }
+
+
+def _Args(parser, include_log_config):
+  """Set up arguments to create a gRPC HealthCheck."""
+  parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
+  flags.HealthCheckArgument('gRPC').AddArgument(parser, operation_type='create')
+  health_checks_utils.AddGrpcRelatedCreationArgs(parser)
+  health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'gRPC')
+  if include_log_config:
+    health_checks_utils.AddHealthCheckLoggingRelatedArgs(parser)
+
+  parser.display_info.AddCacheUpdater(completers.HealthChecksCompleterAlpha)
+
+
+def _Run(args, holder, include_log_config):
+  """Issues the request necessary for adding the health check."""
+  client = holder.client
+  messages = client.messages
+
+  # Check that port related flags are set for gRPC health check.
+  args_unset = not (args.port or args.use_serving_port)
+  if args_unset:
+    raise exceptions.OneOfArgumentsRequiredException([
+        '--port', '--use-serving-port'
+    ], 'Either --port or --use-serving-port must be set for gRPC health check.')
+
+  health_check_ref = flags.HealthCheckArgument('gRPC').ResolveAsResource(
+      args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL)
+  grpc_health_check = messages.GRPCHealthCheck(
+      port=args.port, grpcServiceName=args.grpc_service_name)
+
+  health_checks_utils.ValidateAndAddPortSpecificationToGRPCHealthCheck(
+      args, grpc_health_check)
+
+  if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
+    request = messages.ComputeRegionHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.GRPC,
+            grpcHealthCheck=grpc_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project,
+        region=health_check_ref.region)
+    collection = client.apitools_client.regionHealthChecks
+  else:
+    request = messages.ComputeHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.GRPC,
+            grpcHealthCheck=grpc_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project)
+    collection = client.apitools_client.healthChecks
+
+  if include_log_config:
+    request.healthCheck.logConfig = health_checks_utils.CreateLogConfig(
+        client, args)
+
+  return client.MakeRequests([(collection, 'Insert', request)])
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA)
+class Create(base.CreateCommand):
+  """Create a gRPC health check."""
+
+  detailed_help = _DetailedHelp()
+
+  _include_log_config = True
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(parser, cls._include_log_config)
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(args, holder, self._include_log_config)
+
+
+@base.ReleaseTracks(base.ReleaseTrack.BETA)
+class CreateBeta(Create):
+
+  pass
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class CreateAlpha(CreateBeta):
+
+  pass

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

@@ -0,0 +1,186 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2025 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 gRPC with TLS health checks."""
+
+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 health_checks_utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.calliope import exceptions
+from googlecloudsdk.command_lib.compute import completers
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.health_checks import flags
+
+
+def _DetailedHelp():
+  return {
+      'brief': (
+          'Create a gRPC with TLS health check to monitor load balanced'
+          ' instances.'
+      ),
+      'DESCRIPTION': """\
+      *{command}* is used to create a non-legacy health check using the gRPC with TLS
+      protocol. You can use this health check for Google Cloud load
+      balancers or for managed instance group autohealing. For more information,
+      see the health checks overview at:
+      [](https://cloud.google.com/load-balancing/docs/health-check-concepts)
+      """,
+  }
+
+
+def _Args(parser, include_log_config):
+  """Set up arguments to create a gRPC with TLS HealthCheck."""
+  parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
+  flags.HealthCheckArgument('gRPC with TLS').AddArgument(
+      parser, operation_type='create'
+  )
+  health_checks_utils.AddGrpcRelatedCreationArgs(parser)
+  health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'gRPC with TLS')
+  if include_log_config:
+    health_checks_utils.AddHealthCheckLoggingRelatedArgs(parser)
+
+  parser.display_info.AddCacheUpdater(completers.HealthChecksCompleterAlpha)
+
+
+def _Run(args, holder, include_log_config):
+  """Issues the request necessary for adding the health check."""
+  client = holder.client
+  messages = client.messages
+
+  # Check that port related flags are set for gRPC with TLS health check.
+  args_unset = not (args.port or args.use_serving_port)
+  if args_unset:
+    raise exceptions.OneOfArgumentsRequiredException(
+        ['--port', '--use-serving-port'],
+        'Either --port or --use-serving-port must be set for gRPC with TLS'
+        ' health check.',
+    )
+
+  health_check_ref = flags.HealthCheckArgument(
+      'gRPC with TLS'
+  ).ResolveAsResource(
+      args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL
+  )
+  grpc_tls_health_check = messages.GRPCTLSHealthCheck(
+      port=args.port, grpcServiceName=args.grpc_service_name
+  )
+
+  health_checks_utils.ValidateAndAddPortSpecificationToGRPCHealthCheck(
+      args, grpc_tls_health_check
+  )
+
+  if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
+    request = messages.ComputeRegionHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.GRPC_WITH_TLS,
+            grpcTlsHealthCheck=grpc_tls_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold,
+        ),
+        project=health_check_ref.project,
+        region=health_check_ref.region,
+    )
+    collection = client.apitools_client.regionHealthChecks
+  else:
+    request = messages.ComputeHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.GRPC_WITH_TLS,
+            grpcTlsHealthCheck=grpc_tls_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold,
+        ),
+        project=health_check_ref.project,
+    )
+    collection = client.apitools_client.healthChecks
+
+  if include_log_config:
+    request.healthCheck.logConfig = health_checks_utils.CreateLogConfig(
+        client, args)
+
+  return client.MakeRequests([(collection, 'Insert', request)])
+
+
+@base.DefaultUniverseOnly
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class CreateAlpha(base.CreateCommand):
+  """Create a gRPC with TLS health check."""
+
+  detailed_help = _DetailedHelp()
+
+  _include_log_config = True
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(parser, cls._include_log_config)
+
+  def Run(self, args):
+    return _Run(
+        args,
+        base_classes.ComputeApiHolder(self.ReleaseTrack()),
+        self._include_log_config,
+    )
+
+
+@base.DefaultUniverseOnly
+@base.ReleaseTracks(base.ReleaseTrack.BETA)
+class CreateBeta(base.CreateCommand):
+  """Create a gRPC with TLS health check."""
+
+  detailed_help = _DetailedHelp()
+
+  _include_log_config = True
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(parser, cls._include_log_config)
+
+  def Run(self, args):
+    return _Run(
+        args,
+        base_classes.ComputeApiHolder(self.ReleaseTrack()),
+        self._include_log_config,
+    )
+
+
+@base.DefaultUniverseOnly
+@base.ReleaseTracks(base.ReleaseTrack.GA)
+class CreateGa(base.CreateCommand):
+  """Create a gRPC with TLS health check."""
+
+  detailed_help = _DetailedHelp()
+
+  _include_log_config = True
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(parser, cls._include_log_config)
+
+  def Run(self, args):
+    return _Run(
+        args,
+        base_classes.ComputeApiHolder(self.ReleaseTrack()),
+        self._include_log_config,
+    )

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

@@ -0,0 +1,175 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2015 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 HTTP health checks."""
+
+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 health_checks_utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import completers
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.health_checks import flags
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Create a HTTP health check to monitor load balanced instances.',
+      'DESCRIPTION':
+          """\
+      *{command}* is used to create a non-legacy health check using the HTTP
+      protocol. You can use this health check for Google Cloud load
+      balancers or for managed instance group autohealing. For more information,
+      see the health checks overview at:
+      [](https://cloud.google.com/load-balancing/docs/health-check-concepts)
+      """,
+  }
+
+
+def _Args(
+    parser,
+    include_log_config,
+    include_weighted_load_balancing,
+    include_source_regions,
+):
+  """Set up arguments to create a HTTP HealthCheck."""
+  parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
+  flags.HealthCheckArgument('HTTP').AddArgument(parser, operation_type='create')
+  health_checks_utils.AddHttpRelatedCreationArgs(
+      parser, include_weighted_load_balancing)
+  health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'HTTP')
+  health_checks_utils.AddHttpRelatedResponseArg(parser)
+  if include_source_regions:
+    health_checks_utils.AddHealthCheckSourceRegionsRelatedArgs(parser)
+  if include_log_config:
+    health_checks_utils.AddHealthCheckLoggingRelatedArgs(parser)
+
+  parser.display_info.AddCacheUpdater(completers.HealthChecksCompleterAlpha)
+
+
+def _Run(
+    args,
+    holder,
+    include_log_config,
+    include_weighted_load_balancing,
+    include_source_regions,
+):
+  """Issues the request necessary for adding the health check."""
+  client = holder.client
+  messages = client.messages
+
+  health_check_ref = flags.HealthCheckArgument('HTTP').ResolveAsResource(
+      args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL)
+  proxy_header = messages.HTTPHealthCheck.ProxyHeaderValueValuesEnum(
+      args.proxy_header)
+
+  http_health_check = messages.HTTPHealthCheck(
+      host=args.host,
+      port=args.port,
+      portName=args.port_name,
+      requestPath=args.request_path,
+      proxyHeader=proxy_header,
+      response=args.response)
+
+  if include_weighted_load_balancing and args.weight_report_mode:
+    weight_report_mode = messages.HTTPHealthCheck.WeightReportModeValueValuesEnum(
+        args.weight_report_mode)
+    http_health_check.weightReportMode = weight_report_mode
+
+  health_checks_utils.ValidateAndAddPortSpecificationToHealthCheck(
+      args, http_health_check)
+
+  if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
+    request = messages.ComputeRegionHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.HTTP,
+            httpHealthCheck=http_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project,
+        region=health_check_ref.region)
+    collection = client.apitools_client.regionHealthChecks
+  else:
+    request = messages.ComputeHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.HTTP,
+            httpHealthCheck=http_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project)
+    collection = client.apitools_client.healthChecks
+
+  if include_log_config:
+    request.healthCheck.logConfig = health_checks_utils.CreateLogConfig(
+        client, args)
+
+  if include_source_regions and (args.source_regions is not None):
+    request.healthCheck.sourceRegions = args.source_regions
+
+  return client.MakeRequests([(collection, 'Insert', request)])
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA)
+@base.DefaultUniverseOnly
+class Create(base.CreateCommand):
+  """Create a HTTP health check."""
+
+  detailed_help = _DetailedHelp()
+
+  _include_log_config = True
+  _include_weighted_load_balancing = False
+  _include_source_regions = True
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(
+        parser,
+        cls._include_log_config,
+        cls._include_weighted_load_balancing,
+        cls._include_source_regions,
+    )
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(
+        args,
+        holder,
+        self._include_log_config,
+        self._include_weighted_load_balancing,
+        self._include_source_regions,
+    )
+
+
+@base.ReleaseTracks(base.ReleaseTrack.BETA)
+class CreateBeta(Create):
+
+  _include_weighted_load_balancing = False
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class CreateAlpha(CreateBeta):
+
+  _include_weighted_load_balancing = True

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

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2015 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 HTTP2 health checks."""
+
+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 health_checks_utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import completers
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.health_checks import flags
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Create a HTTP2 health check to monitor load balanced instances',
+      'DESCRIPTION':
+          """\
+          *{command}* is used to create a non-legacy health check using the
+          HTTP/2 protocol. You can use this health check for Google Cloud
+          load balancers or for managed instance group autohealing.
+          For more information, see the health checks overview at:
+          [](https://cloud.google.com/load-balancing/docs/health-check-concepts)
+          """,
+      'EXAMPLES':
+          """\
+          To create a HTTP2 health check with default options, run:
+
+            $ {command} my-health-check-name
+          """,
+  }
+
+
+def _Args(parser, include_log_config, include_weighted_load_balancing):
+  """Set up arguments to create an HTTP2 HealthCheck."""
+  parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
+  flags.HealthCheckArgument('HTTP2').AddArgument(
+      parser, operation_type='create')
+  health_checks_utils.AddHttpRelatedCreationArgs(
+      parser, include_weighted_load_balancing)
+  health_checks_utils.AddHttpRelatedResponseArg(parser)
+  health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'HTTP2')
+  if include_log_config:
+    health_checks_utils.AddHealthCheckLoggingRelatedArgs(parser)
+  parser.display_info.AddCacheUpdater(completers.HealthChecksCompleterAlpha)
+
+
+def _Run(args, holder, include_log_config, include_weighted_load_balancing):
+  """Issues the request necessary for adding the health check."""
+  client = holder.client
+  messages = client.messages
+
+  health_check_ref = flags.HealthCheckArgument('HTTP2').ResolveAsResource(
+      args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL)
+  proxy_header = messages.HTTP2HealthCheck.ProxyHeaderValueValuesEnum(
+      args.proxy_header)
+
+  http2_health_check = messages.HTTP2HealthCheck(
+      host=args.host,
+      port=args.port,
+      portName=args.port_name,
+      requestPath=args.request_path,
+      proxyHeader=proxy_header,
+      response=args.response)
+
+  if include_weighted_load_balancing and args.weight_report_mode:
+    weight_report_mode = messages.HTTP2HealthCheck.WeightReportModeValueValuesEnum(
+        args.weight_report_mode)
+    http2_health_check.weightReportMode = weight_report_mode
+
+  health_checks_utils.ValidateAndAddPortSpecificationToHealthCheck(
+      args, http2_health_check)
+
+  if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
+    request = messages.ComputeRegionHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.HTTP2,
+            http2HealthCheck=http2_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold,
+        ),
+        project=health_check_ref.project,
+        region=health_check_ref.region)
+    collection = client.apitools_client.regionHealthChecks
+  else:
+    request = messages.ComputeHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.HTTP2,
+            http2HealthCheck=http2_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project)
+    collection = client.apitools_client.healthChecks
+
+  if include_log_config:
+    request.healthCheck.logConfig = health_checks_utils.CreateLogConfig(
+        client, args)
+
+  return client.MakeRequests([(collection, 'Insert', request)])
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA)
+class Create(base.CreateCommand):
+  """Create a HTTP2 health check."""
+
+  _include_log_config = True
+  _include_weighted_load_balancing = False
+  detailed_help = _DetailedHelp()
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(parser, cls._include_log_config, cls._include_weighted_load_balancing)
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(args, holder, self._include_log_config,
+                self._include_weighted_load_balancing)
+
+
+@base.ReleaseTracks(base.ReleaseTrack.BETA)
+class CreateBeta(Create):
+
+  _include_weighted_load_balancing = False
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class CreateAlpha(CreateBeta):
+
+  _include_weighted_load_balancing = True

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

@@ -0,0 +1,174 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2015 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 HTTPS health checks."""
+
+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 health_checks_utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import completers
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.health_checks import flags
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Create a HTTPS health check to monitor load balanced instances',
+      'DESCRIPTION':
+          """\
+        *{command}* is used to create a non-legacy health check using the HTTPS
+        protocol. You can use this health check for Google Cloud
+        load balancers or for managed instance group autohealing. For more
+        information, see the health checks overview at:
+        [](https://cloud.google.com/load-balancing/docs/health-check-concepts)
+        """,
+  }
+
+
+def _Args(
+    parser,
+    include_log_config,
+    include_weighted_load_balancing,
+    include_source_regions,
+):
+  """Set up arguments to create an HTTPS HealthCheck."""
+  parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
+  flags.HealthCheckArgument('HTTPS').AddArgument(
+      parser, operation_type='create')
+  health_checks_utils.AddHttpRelatedCreationArgs(
+      parser, include_weighted_load_balancing)
+  health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'HTTPS')
+  health_checks_utils.AddHttpRelatedResponseArg(parser)
+  if include_source_regions:
+    health_checks_utils.AddHealthCheckSourceRegionsRelatedArgs(parser)
+  if include_log_config:
+    health_checks_utils.AddHealthCheckLoggingRelatedArgs(parser)
+  parser.display_info.AddCacheUpdater(completers.HealthChecksCompleterAlpha)
+
+
+def _Run(
+    args,
+    holder,
+    include_log_config,
+    include_weighted_load_balancing,
+    include_source_regions,
+):
+  """Issues the request necessary for adding the health check."""
+  client = holder.client
+  messages = client.messages
+
+  health_check_ref = flags.HealthCheckArgument('HTTPS').ResolveAsResource(
+      args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL)
+  proxy_header = messages.HTTPSHealthCheck.ProxyHeaderValueValuesEnum(
+      args.proxy_header)
+
+  https_health_check = messages.HTTPSHealthCheck(
+      host=args.host,
+      port=args.port,
+      portName=args.port_name,
+      requestPath=args.request_path,
+      proxyHeader=proxy_header,
+      response=args.response)
+
+  if include_weighted_load_balancing and args.weight_report_mode:
+    weight_report_mode = messages.HTTPSHealthCheck.WeightReportModeValueValuesEnum(
+        args.weight_report_mode)
+    https_health_check.weightReportMode = weight_report_mode
+
+  health_checks_utils.ValidateAndAddPortSpecificationToHealthCheck(
+      args, https_health_check)
+
+  if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
+    request = messages.ComputeRegionHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.HTTPS,
+            httpsHealthCheck=https_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project,
+        region=health_check_ref.region)
+    collection = client.apitools_client.regionHealthChecks
+  else:
+    request = messages.ComputeHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.HTTPS,
+            httpsHealthCheck=https_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project)
+    collection = client.apitools_client.healthChecks
+
+  if include_log_config:
+    request.healthCheck.logConfig = health_checks_utils.CreateLogConfig(
+        client, args)
+
+  if include_source_regions and (args.source_regions is not None):
+    request.healthCheck.sourceRegions = args.source_regions
+
+  return client.MakeRequests([(collection, 'Insert', request)])
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA)
+@base.DefaultUniverseOnly
+class Create(base.CreateCommand):
+  """Create a HTTPS health check."""
+
+  _include_log_config = True
+  _include_weighted_load_balancing = False
+  _include_source_regions = True
+  detailed_help = _DetailedHelp()
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(
+        parser,
+        cls._include_log_config,
+        cls._include_weighted_load_balancing,
+        cls._include_source_regions,
+    )
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(
+        args,
+        holder,
+        self._include_log_config,
+        self._include_weighted_load_balancing,
+        self._include_source_regions,
+    )
+
+
+@base.ReleaseTracks(base.ReleaseTrack.BETA)
+class CreateBeta(Create):
+
+  _include_weighted_load_balancing = False
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class CreateAlpha(CreateBeta):
+
+  _include_weighted_load_balancing = True

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

@@ -0,0 +1,132 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2015 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 SSL health checks."""
+
+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 health_checks_utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.health_checks import flags
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Create a SSL health check to monitor load balanced instances.',
+      'DESCRIPTION':
+          """\
+          *{command}* is used to create a non-legacy health check using the SSL
+          protocol. You can use this health check for Google Cloud
+          load balancers or for managed instance group autohealing. For more
+          information, see the health checks overview at:
+          [](https://cloud.google.com/load-balancing/docs/health-check-concepts)
+          """,
+  }
+
+
+def _Args(parser, include_log_config):
+  """Set up arguments to create an SSL HealthCheck."""
+  parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
+  flags.HealthCheckArgument('SSL').AddArgument(parser, operation_type='create')
+  health_checks_utils.AddTcpRelatedCreationArgs(parser)
+  health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'SSL')
+  if include_log_config:
+    health_checks_utils.AddHealthCheckLoggingRelatedArgs(parser)
+
+
+def _Run(args, holder, include_log_config):
+  """Issues the request necessary for adding the health check."""
+  client = holder.client
+  messages = client.messages
+
+  health_check_ref = flags.HealthCheckArgument('SSL').ResolveAsResource(
+      args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL)
+  proxy_header = messages.SSLHealthCheck.ProxyHeaderValueValuesEnum(
+      args.proxy_header)
+  ssl_health_check = messages.SSLHealthCheck(
+      request=args.request,
+      response=args.response,
+      port=args.port,
+      portName=args.port_name,
+      proxyHeader=proxy_header)
+
+  health_checks_utils.ValidateAndAddPortSpecificationToHealthCheck(
+      args, ssl_health_check)
+
+  if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
+    request = messages.ComputeRegionHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.SSL,
+            sslHealthCheck=ssl_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project,
+        region=health_check_ref.region)
+    collection = client.apitools_client.regionHealthChecks
+  else:
+    request = messages.ComputeHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.SSL,
+            sslHealthCheck=ssl_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project)
+    collection = client.apitools_client.healthChecks
+
+  if include_log_config:
+    request.healthCheck.logConfig = health_checks_utils.CreateLogConfig(
+        client, args)
+
+  return client.MakeRequests([(collection, 'Insert', request)])
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA)
+class Create(base.CreateCommand):
+  """Create a SSL health check."""
+
+  _include_log_config = True
+  detailed_help = _DetailedHelp()
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(parser, cls._include_log_config)
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(args, holder, self._include_log_config)
+
+
+@base.ReleaseTracks(base.ReleaseTrack.BETA)
+class CreateBeta(Create):
+
+  pass
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class CreateAlpha(CreateBeta):
+
+  pass

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

@@ -0,0 +1,141 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2015 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 TCP health checks."""
+
+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 health_checks_utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute import scope as compute_scope
+from googlecloudsdk.command_lib.compute.health_checks import flags
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Create a TCP health check to monitor load balanced instances.',
+      'DESCRIPTION':
+          """\
+          *{command}* is used to create a non-legacy health check using the TCP
+          protocol. You can use this health check for Google Cloud
+          load balancers or for managed instance group autohealing. For more
+          information, see the health checks overview at:
+          [](https://cloud.google.com/load-balancing/docs/health-check-concepts)
+          """,
+  }
+
+
+def _Args(parser, include_log_config, include_source_regions):
+  """Set up arguments to create an HTTP2 HealthCheck."""
+  parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
+  flags.HealthCheckArgument('TCP').AddArgument(parser, operation_type='create')
+  health_checks_utils.AddTcpRelatedCreationArgs(parser)
+  health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'TCP')
+  if include_source_regions:
+    health_checks_utils.AddHealthCheckSourceRegionsRelatedArgs(parser)
+  if include_log_config:
+    health_checks_utils.AddHealthCheckLoggingRelatedArgs(parser)
+
+
+def _Run(args, holder, include_log_config, include_source_regions):
+  """Issues the request necessary for adding the health check."""
+  client = holder.client
+  messages = client.messages
+
+  health_check_ref = flags.HealthCheckArgument('TCP').ResolveAsResource(
+      args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL)
+  proxy_header = messages.TCPHealthCheck.ProxyHeaderValueValuesEnum(
+      args.proxy_header)
+  tcp_health_check = messages.TCPHealthCheck(
+      request=args.request,
+      response=args.response,
+      port=args.port,
+      portName=args.port_name,
+      proxyHeader=proxy_header)
+
+  health_checks_utils.ValidateAndAddPortSpecificationToHealthCheck(
+      args, tcp_health_check)
+
+  if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
+    request = messages.ComputeRegionHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.TCP,
+            tcpHealthCheck=tcp_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project,
+        region=health_check_ref.region)
+    collection = client.apitools_client.regionHealthChecks
+  else:
+    request = messages.ComputeHealthChecksInsertRequest(
+        healthCheck=messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=messages.HealthCheck.TypeValueValuesEnum.TCP,
+            tcpHealthCheck=tcp_health_check,
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold),
+        project=health_check_ref.project)
+    collection = client.apitools_client.healthChecks
+
+  if include_log_config:
+    request.healthCheck.logConfig = health_checks_utils.CreateLogConfig(
+        client, args)
+
+  if include_source_regions and (args.source_regions is not None):
+    request.healthCheck.sourceRegions = args.source_regions
+
+  return client.MakeRequests([(collection, 'Insert', request)])
+
+
+@base.ReleaseTracks(base.ReleaseTrack.GA)
+@base.DefaultUniverseOnly
+class Create(base.CreateCommand):
+  """Create a TCP health."""
+
+  _include_log_config = True
+  _include_source_regions = True
+  detailed_help = _DetailedHelp()
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(parser, cls._include_log_config, cls._include_source_regions)
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(
+        args, holder, self._include_log_config, self._include_source_regions
+    )
+
+
+@base.ReleaseTracks(base.ReleaseTrack.BETA)
+class CreateBeta(Create):
+
+  pass
+
+
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class CreateAlpha(CreateBeta):
+
+  pass

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

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*- #
+# Copyright 2016 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 UDP health checks."""
+
+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 health_checks_utils
+from googlecloudsdk.calliope import base
+from googlecloudsdk.command_lib.compute.health_checks import exceptions
+from googlecloudsdk.command_lib.compute.health_checks import flags
+
+
+def _DetailedHelp():
+  return {
+      'brief':
+          'Create a UDP health check to monitor load balanced instances.',
+      'DESCRIPTION':
+          """\
+          *{command}* is used to create a UDP health check. UDP health checks
+        monitor instances in a load balancer controlled by a target pool. All
+        arguments to the command are optional except for the name of the health
+        check, request and response. For more information on load balancing, see
+        [](https://cloud.google.com/compute/docs/load-balancing-and-autoscaling/)
+          """,
+  }
+
+
+def _Args(parser):
+  parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
+  flags.HealthCheckArgument('UDP').AddArgument(parser, operation_type='create')
+  health_checks_utils.AddUdpRelatedArgs(parser)
+  health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'UDP')
+
+
+def _Run(args, holder):
+  """Issues the request necessary for adding the health check."""
+  client = holder.client
+
+  health_check_ref = flags.HealthCheckArgument('UDP').ResolveAsResource(
+      args, holder.resources)
+
+  # Check that request and response are not None and empty.
+  if not args.request:
+    raise exceptions.ArgumentError('"request" field for UDP can not be empty.')
+  if not args.response:
+    raise exceptions.ArgumentError('"response" field for UDP can not be empty.')
+
+  if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
+    request = client.messages.ComputeRegionHealthChecksInsertRequest(
+        healthCheck=client.messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=client.messages.HealthCheck.TypeValueValuesEnum.UDP,
+            udpHealthCheck=client.messages.UDPHealthCheck(
+                request=args.request,
+                response=args.response,
+                port=args.port,
+                portName=args.port_name),
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold,
+        ),
+        project=health_check_ref.project,
+        region=health_check_ref.region)
+    collection = client.apitools_client.regionHealthChecks
+  else:
+    request = client.messages.ComputeHealthChecksInsertRequest(
+        healthCheck=client.messages.HealthCheck(
+            name=health_check_ref.Name(),
+            description=args.description,
+            type=client.messages.HealthCheck.TypeValueValuesEnum.UDP,
+            udpHealthCheck=client.messages.UDPHealthCheck(
+                request=args.request,
+                response=args.response,
+                port=args.port,
+                portName=args.port_name),
+            checkIntervalSec=args.check_interval,
+            timeoutSec=args.timeout,
+            healthyThreshold=args.healthy_threshold,
+            unhealthyThreshold=args.unhealthy_threshold,
+        ),
+        project=health_check_ref.project)
+    collection = client.apitools_client.healthChecks
+
+  return client.MakeRequests([(collection, 'Insert', request)])
+
+
+@base.Hidden
+@base.ReleaseTracks(base.ReleaseTrack.ALPHA)
+class CreateAlpha(base.CreateCommand):
+  """Create an Alpha UDP health check to monitor load balanced instances.
+
+  Business logic should be put in helper functions. Classes annotated with
+  @base.ReleaseTracks should only be concerned with calling helper functions
+  with the correct feature parameters.
+  """
+
+  detailed_help = _DetailedHelp()
+
+  @classmethod
+  def Args(cls, parser):
+    _Args(parser)
+
+  def Run(self, args):
+    holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
+    return _Run(args, holder)