def _Run(holder, args, include_l7_internal_load_balancing):
"""Issues the request necessary for deleting the health check."""
client = holder.client
health_check_arg = flags.HealthCheckArgument(
'',
plural=True,
include_l7_internal_load_balancing=include_l7_internal_load_balancing)
health_check_refs = health_check_arg.ResolveAsResource(
args,
holder.resources,
default_scope=compute_scope.ScopeEnum.GLOBAL,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(health_check_refs)
requests = []
for health_check_ref in health_check_refs:
if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
requests.append(
(client.apitools_client.regionHealthChecks, 'Delete',
client.messages.ComputeRegionHealthChecksDeleteRequest(
**health_check_ref.AsDict())))
else:
requests.append((client.apitools_client.healthChecks, 'Delete',
client.messages.ComputeHealthChecksDeleteRequest(
**health_check_ref.AsDict())))
return client.MakeRequests(requests)
def Args(cls, parser, regionalized=False):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
flags.HealthCheckArgument('SSL',
include_alpha=regionalized).AddArgument(
parser, operation_type='create')
health_checks_utils.AddTcpRelatedCreationArgs(parser)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'SSL')
def Args(cls, parser, supports_use_serving_port=False):
cls.HEALTH_CHECK_ARG = flags.HealthCheckArgument('HTTPS')
cls.HEALTH_CHECK_ARG.AddArgument(parser, operation_type='update')
health_checks_utils.AddHttpRelatedUpdateArgs(
parser, supports_use_serving_port)
health_checks_utils.AddProtocolAgnosticUpdateArgs(parser, 'HTTPS')
health_checks_utils.AddHttpRelatedResponseArg(parser)
def Args(cls, parser, supports_port_specification=False):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
flags.HealthCheckArgument('TCP').AddArgument(parser,
operation_type='create')
health_checks_utils.AddTcpRelatedCreationArgs(
parser, port_specification=supports_port_specification)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'TCP')
def Args(cls, parser):
cls.HEALTH_CHECK_ARG = flags.HealthCheckArgument(
'UDP', include_l7_internal_load_balancing=True)
cls.HEALTH_CHECK_ARG.AddArgument(parser, operation_type='update')
health_checks_utils.AddUdpRelatedArgs(
parser, request_and_response_required=False)
health_checks_utils.AddProtocolAgnosticUpdateArgs(parser, 'UDP')
def Args(cls, parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
cls.HEALTH_CHECK_ARG = flags.HealthCheckArgument(
'UDP', include_l7_internal_load_balancing=True)
cls.HEALTH_CHECK_ARG.AddArgument(parser, operation_type='create')
health_checks_utils.AddUdpRelatedArgs(parser)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'UDP')
def _Args(parser, include_l7_internal_load_balancing):
health_check_arg = flags.HealthCheckArgument(
'SSL',
include_l7_internal_load_balancing=include_l7_internal_load_balancing)
health_check_arg.AddArgument(parser, operation_type='update')
health_checks_utils.AddTcpRelatedUpdateArgs(parser)
health_checks_utils.AddProtocolAgnosticUpdateArgs(parser, 'SSL')
def Args(cls, parser):
cls.HEALTH_CHECK_ARG = flags.HealthCheckArgument(
'HTTPS', include_l7_internal_load_balancing=True)
cls.HEALTH_CHECK_ARG.AddArgument(parser, operation_type='update')
health_checks_utils.AddHttpRelatedUpdateArgs(parser)
health_checks_utils.AddProtocolAgnosticUpdateArgs(parser, 'HTTPS')
health_checks_utils.AddHttpRelatedResponseArg(parser)
def _Run(args, holder, supports_port_specification=False):
"""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)
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)
if supports_port_specification:
health_checks_utils.ValidateAndAddPortSpecificationToHealthCheck(
args, ssl_health_check)
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)
return client.MakeRequests([(client.apitools_client.healthChecks, 'Insert',
request)])
def Args(cls, parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
cls.HEALTH_CHECK_ARG = flags.HealthCheckArgument('HTTP2')
cls.HEALTH_CHECK_ARG.AddArgument(parser)
health_checks_utils.AddHttpRelatedCreationArgs(parser)
health_checks_utils.AddHttpRelatedResponseArg(parser)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'HTTP2')
def _Run(args, holder, include_l7_internal_load_balancing):
"""Issues the requests necessary for updating the health check."""
client = holder.client
_ValidateArgs(args)
health_check_arg = flags.HealthCheckArgument(
'HTTPS',
include_l7_internal_load_balancing=include_l7_internal_load_balancing)
health_check_ref = health_check_arg.ResolveAsResource(
args, holder.resources)
if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
get_request = _GetRegionalGetRequest(client, health_check_ref)
else:
get_request = _GetGetRequest(client, health_check_ref)
objects = client.MakeRequests([get_request])
new_object = _Modify(client, args, objects[0])
# If existing object is equal to the proposed object or if
# _Modify() returns None, then there is no work to be done, so we
# print the resource and return.
if objects[0] == new_object:
log.status.Print(
'No change requested; skipping update for [{0}].'.format(
objects[0].name))
return objects
if health_checks_utils.IsRegionalHealthCheckRef(health_check_ref):
set_request = _GetRegionalSetRequest(client, health_check_ref,
new_object)
else:
set_request = _GetSetRequest(client, health_check_ref, new_object)
return client.MakeRequests([set_request])
def Args(cls, parser, include_alpha=False):
cls.HEALTH_CHECK_ARG = flags.HealthCheckArgument(
'HTTP', include_alpha=include_alpha)
cls.HEALTH_CHECK_ARG.AddArgument(parser, operation_type='update')
health_checks_utils.AddHttpRelatedUpdateArgs(parser)
health_checks_utils.AddProtocolAgnosticUpdateArgs(parser, 'HTTP')
health_checks_utils.AddHttpRelatedResponseArg(parser)
def Args(cls, parser):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
flags.HealthCheckArgument('HTTP').AddArgument(parser,
operation_type='create')
health_checks_utils.AddHttpRelatedCreationArgs(parser)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'HTTP')
parser.display_info.AddCacheUpdater(completers.HealthChecksCompleter)
class CreateAlpha(CreateBeta):
"""Create Google Compute Engine managed instance groups."""
HEALTH_CHECK_ARG = health_checks_flags.HealthCheckArgument(
'', '--health-check', required=False)
@classmethod
def Args(cls, parser):
health_check_group = parser.add_mutually_exclusive_group()
cls.HEALTH_CHECK_ARG.AddArgument(health_check_group)
parser.display_info.AddFormat(managed_flags.DEFAULT_LIST_FORMAT)
_AddInstanceGroupManagerArgs(parser=parser)
auto_healing_utils.AddAutohealingArgs(
parser=parser, health_check_group=health_check_group)
igm_arg = instance_groups_flags.GetInstanceGroupManagerArg(zones_flag=True)
igm_arg.AddArgument(parser, operation_type='create')
instance_groups_flags.AddZonesFlag(parser)
instance_groups_flags.AddSettingStatefulDisksFlag(parser)
def _GetStatefulPolicy(self, stateful_disks, client):
if stateful_disks is None:
return None
disks = [
client.messages.StatefulPolicyPreservedDisk(deviceName=device)
for device in stateful_disks
]
preserved_resources = client.messages.StatefulPolicyPreservedResources(
disks=disks
)
return client.messages.StatefulPolicy(
preservedResources=preserved_resources)
def _CreateInstanceGroupManager(
self, args, group_ref, template_ref, client, holder):
"""Create parts of Instance Group Manager shared for the track."""
if (group_ref.Collection() != 'compute.instanceGroupManagers' and
args.IsSpecified('stateful_disks')):
raise exceptions.BadArgumentException(
'--stateful-disks',
'Allowed only with zonal managed instance groups.')
instance_groups_flags.ValidateManagedInstanceGroupScopeArgs(
args, holder.resources)
health_check = managed_instance_groups_utils.GetHealthCheckUri(
holder.resources, args, self.HEALTH_CHECK_ARG)
return client.messages.InstanceGroupManager(
name=group_ref.Name(),
description=args.description,
instanceTemplate=template_ref.SelfLink(),
baseInstanceName=self._GetInstanceGroupManagerBaseInstanceName(
args.base_instance_name, group_ref),
targetPools=self._GetInstanceGroupManagerTargetPools(
args.target_pool, group_ref, holder),
targetSize=int(args.size),
autoHealingPolicies=(
managed_instance_groups_utils.CreateAutohealingPolicies(
client.messages, health_check, args.initial_delay)),
distributionPolicy=self._CreateDistributionPolicy(
args.zones, holder.resources, client.messages),
statefulPolicy=self._GetStatefulPolicy(args.stateful_disks, client),
)
def Args(cls, parser):
cls.HEALTH_CHECK_ARG = flags.HealthCheckArgument('',
plural=True,
include_alpha=True)
cls.HEALTH_CHECK_ARG.AddArgument(parser, operation_type='delete')
parser.display_info.AddCacheUpdater(
completers.HealthChecksCompleterAlpha)
class CreateBeta(CreateGA):
"""Create Google Compute Engine managed instance groups."""
HEALTH_CHECK_ARG = health_checks_flags.HealthCheckArgument(
'', '--health-check', required=False)
@classmethod
def Args(cls, parser):
health_check_group = parser.add_mutually_exclusive_group()
cls.HEALTH_CHECK_ARG.AddArgument(health_check_group)
parser.display_info.AddFormat(managed_flags.DEFAULT_LIST_FORMAT)
_AddInstanceGroupManagerArgs(parser=parser)
auto_healing_utils.AddAutohealingArgs(
parser=parser, health_check_group=health_check_group)
instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG.AddArgument(
parser, operation_type='create')
def _CreateInstanceGroupManager(self, args, group_ref, template_ref,
client, holder):
"""Create parts of Instance Group Manager shared between tracks."""
health_check = managed_instance_groups_utils.GetHealthCheckUri(
holder.resources, args, self.HEALTH_CHECK_ARG)
return client.messages.InstanceGroupManager(
name=group_ref.Name(),
description=args.description,
instanceTemplate=template_ref.SelfLink(),
baseInstanceName=self._GetInstanceGroupManagerBaseInstanceName(
args.base_instance_name, group_ref),
targetPools=self._GetInstanceGroupManagerTargetPools(
args.target_pool, group_ref, holder),
targetSize=int(args.size),
autoHealingPolicies=(
managed_instance_groups_utils.CreateAutohealingPolicies(
client.messages, health_check, args.initial_delay)),
)
def _Run(args, holder, include_l7_internal_load_balancing, 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.port_name or args.use_serving_port)
if args_unset:
raise exceptions.ToolException(
'Either --port, --port-name or --use-serving-port must be set for gRPC '
'health check.'
)
health_check_ref = flags.HealthCheckArgument(
'gRPC',
include_l7_internal_load_balancing=include_l7_internal_load_balancing
).ResolveAsResource(
args, holder.resources, default_scope=compute_scope.ScopeEnum.GLOBAL)
grpc_health_check = messages.GRPCHealthCheck(
port=args.port,
portName=args.port_name,
grpcServiceName=args.grpc_service_name)
health_checks_utils.ValidateAndAddPortSpecificationToHealthCheck(
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)])
def _Args(parser, include_l7_internal_load_balancing=False):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
flags.HealthCheckArgument(
'UDP',
include_l7_internal_load_balancing=include_l7_internal_load_balancing
).AddArgument(parser, operation_type='create')
health_checks_utils.AddUdpRelatedArgs(parser)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'UDP')
def _Run(args, holder, include_l7_internal_load_balancing, include_log_config):
"""Issues the request necessary for adding the health check."""
client = holder.client
messages = client.messages
health_check_ref = flags.HealthCheckArgument(
'HTTP2',
include_l7_internal_load_balancing=include_l7_internal_load_balancing
).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)
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)])
def _Args(parser, include_l7_internal_load_balancing):
health_check_arg = flags.HealthCheckArgument(
'',
plural=True,
include_l7_internal_load_balancing=include_l7_internal_load_balancing)
health_check_arg.AddArgument(parser, operation_type='delete')
parser.display_info.AddCacheUpdater(completers.HealthChecksCompleterAlpha
if include_l7_internal_load_balancing
else completers.HealthChecksCompleter)
def _Args(parser, include_l7_internal_load_balancing, include_log_config):
health_check_arg = flags.HealthCheckArgument(
'gRPC',
include_l7_internal_load_balancing=include_l7_internal_load_balancing)
health_check_arg.AddArgument(parser, operation_type='update')
health_checks_utils.AddGrpcRelatedUpdateArgs(parser)
health_checks_utils.AddProtocolAgnosticUpdateArgs(parser, 'gRPC')
if include_log_config:
health_checks_utils.AddHealthCheckLoggingRelatedArgs(parser)
def _Run(args,
holder,
supports_response=False,
supports_port_specification=False,
regionalized=False):
"""Issues the request necessary for adding the health check."""
client = holder.client
messages = client.messages
health_check_ref = flags.HealthCheckArgument(
'HTTP2',
include_alpha=regionalized).ResolveAsResource(args, holder.resources)
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)
if supports_response:
http2_health_check.response = args.response
if supports_port_specification:
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
return client.MakeRequests([(collection, 'Insert', request)])
def _Args(parser, include_l7_internal_load_balancing=False):
"""Set up arguments to create an SSL HealthCheck."""
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
flags.HealthCheckArgument(
'SSL',
include_l7_internal_load_balancing=include_l7_internal_load_balancing
).AddArgument(parser, operation_type='create')
health_checks_utils.AddTcpRelatedCreationArgs(parser)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'SSL')
def _Run(args, holder, include_l7_internal_load_balancing=False):
"""Issues the request necessary for adding the health check."""
client = holder.client
health_check_ref = flags.HealthCheckArgument(
'UDP',
include_l7_internal_load_balancing=include_l7_internal_load_balancing
).ResolveAsResource(args, holder.resources)
# Check that request and response are not None and empty.
if not args.request:
raise exceptions.ToolException(
'"request" field for UDP can not be empty.')
if not args.response:
raise exceptions.ToolException(
'"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)])
def _Args(parser, include_l7_internal_load_balancing, include_log_config):
"""Set up arguments to create an HTTP2 HealthCheck."""
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
flags.HealthCheckArgument(
'TCP',
include_l7_internal_load_balancing=include_l7_internal_load_balancing
).AddArgument(parser, operation_type='create')
health_checks_utils.AddTcpRelatedCreationArgs(parser)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'TCP')
if include_log_config:
health_checks_utils.AddHealthCheckLoggingRelatedArgs(parser)
def Args(parser, supports_use_serving_port=True, regionalized=False):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
flags.HealthCheckArgument('HTTP2',
include_alpha=regionalized).AddArgument(
parser, operation_type='create')
health_checks_utils.AddHttpRelatedCreationArgs(parser)
health_checks_utils.AddHttpRelatedResponseArg(parser)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'HTTP2')
parser.display_info.AddCacheUpdater(
completers.HealthChecksCompleterAlpha
if regionalized else completers.HealthChecksCompleter)
def Args(cls, parser, regionalized=False):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
flags.HealthCheckArgument(
'HTTPS',
include_l7_internal_load_balancing=regionalized).AddArgument(
parser, operation_type='create')
health_checks_utils.AddHttpRelatedCreationArgs(parser)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'HTTPS')
health_checks_utils.AddHttpRelatedResponseArg(parser)
parser.display_info.AddCacheUpdater(
completers.HealthChecksCompleterAlpha
if regionalized else completers.HttpsHealthChecksCompleter)
def _Args(parser, include_l7_internal_load_balancing, include_log_config,
include_weighted_load_balancing):
"""Adds all the args in the parser."""
health_check_arg = flags.HealthCheckArgument(
'HTTP2',
include_l7_internal_load_balancing=include_l7_internal_load_balancing)
health_check_arg.AddArgument(parser, operation_type='update')
health_checks_utils.AddHttpRelatedUpdateArgs(
parser, include_weighted_load_balancing)
health_checks_utils.AddHttpRelatedResponseArg(parser)
health_checks_utils.AddProtocolAgnosticUpdateArgs(parser, 'HTTP2')
if include_log_config:
health_checks_utils.AddHealthCheckLoggingRelatedArgs(parser)
def Args(cls,
parser,
supports_port_specification=False,
supports_use_serving_port=False):
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
flags.HealthCheckArgument('HTTP').AddArgument(parser,
operation_type='create')
health_checks_utils.AddHttpRelatedCreationArgs(
parser,
port_specification=supports_port_specification,
use_serving_port=supports_use_serving_port)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'HTTP')
parser.display_info.AddCacheUpdater(completers.HealthChecksCompleter)
def _Args(parser, include_l7_internal_load_balancing=False):
"""Set up arguments to create an HTTP2 HealthCheck."""
parser.display_info.AddFormat(flags.DEFAULT_LIST_FORMAT)
flags.HealthCheckArgument(
'HTTP2',
include_l7_internal_load_balancing=include_l7_internal_load_balancing
).AddArgument(parser, operation_type='create')
health_checks_utils.AddHttpRelatedCreationArgs(parser)
health_checks_utils.AddHttpRelatedResponseArg(parser)
health_checks_utils.AddProtocolAgnosticCreationArgs(parser, 'HTTP2')
parser.display_info.AddCacheUpdater(completers.HealthChecksCompleterAlpha
if include_l7_internal_load_balancing
else completers.HealthChecksCompleter)
