def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
messages = client.messages
health_check = managed_instance_groups_utils.GetHealthCheckUri(
holder.resources, args)
auto_healing_policies = (
managed_instance_groups_utils.CreateAutohealingPolicies(
client.messages, health_check, args.initial_delay))
managed_instance_groups_utils.ValidateAutohealingPolicies(
auto_healing_policies)
resource_arg = instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG
default_scope = compute_scope.ScopeEnum.ZONE
scope_lister = flags.GetDefaultScopeLister(client)
igm_ref = resource_arg.ResolveAsResource(args,
holder.resources,
default_scope=default_scope,
scope_lister=scope_lister)
igm_resource = messages.InstanceGroupManager(
autoHealingPolicies=auto_healing_policies)
if igm_ref.Collection() == 'compute.instanceGroupManagers':
service = client.apitools_client.instanceGroupManagers
request_type = messages.ComputeInstanceGroupManagersPatchRequest
elif igm_ref.Collection() == 'compute.regionInstanceGroupManagers':
service = client.apitools_client.regionInstanceGroupManagers
request_type = messages.ComputeRegionInstanceGroupManagersPatchRequest
else:
raise ValueError('Unknown reference type {0}'.format(
igm_ref.Collection()))
request = request_type(**igm_ref.AsDict())
request.instanceGroupManagerResource = igm_resource
return client.MakeRequests([(service, 'Patch', request)])
def Run(self, args):
instance_ref = instance_flags.INSTANCE_ARG.ResolveAsResource(
args,
self.resources,
scope_lister=flags.GetDefaultScopeLister(self.compute_client,
self.project))
start = None
while True:
request = (
self.compute.instances, 'GetSerialPortOutput',
self.messages.ComputeInstancesGetSerialPortOutputRequest(
instance=instance_ref.Name(),
project=self.project,
port=args.port,
start=start,
zone=instance_ref.zone))
errors = []
objects = list(
request_helper.MakeRequests(requests=[request],
http=self.http,
batch_url=self.batch_url,
errors=errors,
custom_get_requests=None))
if errors:
raise TailSerialPortOutputException(
'Could not fetch serial port output: ' +
','.join([error[1] for error in errors]))
result = objects[0]
log.out.write(result.contents)
start = result.next
# If we didn't get any results, we sleep for a short time before the next
# call.
if not result.contents:
time.sleep(self.POLL_SLEEP_SECS)
def Run(self, args):
"""Invokes request necessary for setting scheduling options."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
self._ValidateMachineTypePresence(args)
instance_ref = instance_flags.INSTANCE_ARG.ResolveAsResource(
args, holder.resources, scope_lister=flags.GetDefaultScopeLister(
client))
machine_type = instance_utils.InterpretMachineType(
machine_type=args.machine_type,
custom_cpu=args.custom_cpu,
custom_memory=args.custom_memory,
ext=getattr(args, 'custom_extensions', None))
instance_utils.CheckCustomCpuRamRatio(client,
instance_ref.project,
instance_ref.zone, machine_type)
machine_type_uri = holder.resources.Parse(
machine_type, collection='compute.machineTypes',
params={
'project': instance_ref.project,
'zone': instance_ref.zone
}).SelfLink()
set_machine_type_request = client.messages.InstancesSetMachineTypeRequest(
machineType=machine_type_uri)
request = client.messages.ComputeInstancesSetMachineTypeRequest(
instance=instance_ref.Name(),
project=instance_ref.project,
instancesSetMachineTypeRequest=set_machine_type_request,
zone=instance_ref.zone)
return client.MakeRequests([(client.apitools_client.instances,
'SetMachineType', request)])
def Run(self, args):
"""Issues API requests to update a External VPN gateway.
Args:
args: argparse.Namespace, The arguments received by this command.
Returns:
[protorpc.messages.Message], A list of responses returned
by the compute API.
"""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
messages = holder.client.messages
helper = external_vpn_gateways_utils.ExternalVpnGatewayHelper(holder)
external_gateway_ref = _EXTERNAL_VPN_GATEWAY_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
labels_diff = labels_util.Diff.FromUpdateArgs(args)
if not labels_diff.MayHaveUpdates():
raise calliope_exceptions.RequiredArgumentException(
'LABELS', 'At least one of --update-labels or '
'--remove-labels must be specified.')
external_vpn_gateway = helper.Describe(external_gateway_ref)
labels_update = labels_diff.Apply(
messages.GlobalSetLabelsRequest.LabelsValue,
external_vpn_gateway.labels)
if not labels_update.needs_update:
return external_vpn_gateway
operation_ref = helper.SetLabels(external_gateway_ref,
external_vpn_gateway.labelFingerprint,
labels_update.labels)
return helper.WaitForOperation(
external_gateway_ref, operation_ref,
'Updating labels of external VPN gateway [{0}]'.format(
external_gateway_ref.Name()))
def Run(self, args):
"""Returns a list of TargetPoolInstanceHealth objects."""
self.target_pool_ref = self.TARGET_POOL_ARG.ResolveAsResource(
args,
self.resources,
scope_lister=compute_flags.GetDefaultScopeLister(
self.compute_client, self.project))
target_pool = self.GetTargetPool()
instances = target_pool.instances
# If the target pool has no instances, we should return an empty
# list.
if not instances:
return
requests = []
for instance in instances:
request_message = self.messages.ComputeTargetPoolsGetHealthRequest(
instanceReference=self.messages.InstanceReference(
instance=instance),
project=self.project,
region=self.target_pool_ref.region,
targetPool=self.target_pool_ref.Name())
requests.append((self.service, 'GetHealth', request_message))
errors = []
resources = request_helper.MakeRequests(requests=requests,
http=self.http,
batch_url=self.batch_url,
errors=errors,
custom_get_requests=None)
for resource in resources:
yield resource
if errors:
utils.RaiseToolException(
errors, error_message='Could not get health for some targets:')
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
attachment_ref = self.INTERCONNECT_ATTACHMENT_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
interconnect_attachment = client.InterconnectAttachment(
attachment_ref, compute_client=holder.client)
interconnect_ref = None
if args.interconnect is not None:
interconnect_ref = self.INTERCONNECT_ARG.ResolveAsResource(
args, holder.resources)
if args.router_region is None:
args.router_region = attachment_ref.region
if args.router_region != attachment_ref.region:
raise parser_errors.ArgumentException(
'router-region must be same as the attachment region.')
router_ref = None
if args.router is not None:
router_ref = self.ROUTER_ARG.ResolveAsResource(
args, holder.resources)
return interconnect_attachment.CreateAlpha(
description=args.description,
interconnect=interconnect_ref,
attachment_type='DEDICATED',
router=router_ref,
vlan_tag_802_1q=args.vlan,
admin_enabled=args.admin_enabled,
candidate_subnets=args.candidate_subnets,
bandwidth=getattr(args, 'bandwidth', None),
validate_only=getattr(args, 'dry_run', None),
mtu=getattr(args, 'mtu', None))
def CreateRequests(self, args):
resource_arg = instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG
default_scope = compute_scope.ScopeEnum.ZONE
scope_lister = flags.GetDefaultScopeLister(self.compute_client)
igm_ref = resource_arg.ResolveAsResource(args,
self.resources,
default_scope=default_scope,
scope_lister=scope_lister)
instances = instance_groups_utils.CreateInstanceReferences(
self.resources, self.compute_client, igm_ref, args.instances)
if igm_ref.Collection() == 'compute.instanceGroupManagers':
service = self.compute.instanceGroupManagers
request = (self.messages.
ComputeInstanceGroupManagersRecreateInstancesRequest(
instanceGroupManager=igm_ref.Name(),
instanceGroupManagersRecreateInstancesRequest=(
self.messages.
InstanceGroupManagersRecreateInstancesRequest(
instances=instances, )),
project=igm_ref.project,
zone=igm_ref.zone,
))
else:
service = self.compute.regionInstanceGroupManagers
request = (
self.messages.
ComputeRegionInstanceGroupManagersRecreateInstancesRequest(
instanceGroupManager=igm_ref.Name(),
regionInstanceGroupManagersRecreateRequest=(
self.messages.
RegionInstanceGroupManagersRecreateRequest(
instances=instances, )),
project=igm_ref.project,
region=igm_ref.region,
))
return [(service, self.method, request)]
def CreateRequests(self, args):
igm_ref = (instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG.
ResolveAsResource)(args,
self.resources,
default_scope=flags.ScopeEnum.ZONE,
scope_lister=flags.GetDefaultScopeLister(
self.compute_client, self.project))
template_ref = self.CreateGlobalReference(
args.template, resource_type='instanceTemplates')
if igm_ref.Collection() == 'compute.instanceGroupManagers':
service = self.compute.instanceGroupManagers
request = (
self.messages.
ComputeInstanceGroupManagersSetInstanceTemplateRequest(
instanceGroupManager=igm_ref.Name(),
instanceGroupManagersSetInstanceTemplateRequest=(
self.messages.
InstanceGroupManagersSetInstanceTemplateRequest(
instanceTemplate=template_ref.SelfLink(), )),
project=self.project,
zone=igm_ref.zone,
))
else:
service = self.compute.regionInstanceGroupManagers
request = (
self.messages.
ComputeRegionInstanceGroupManagersSetInstanceTemplateRequest(
instanceGroupManager=igm_ref.Name(),
regionInstanceGroupManagersSetTemplateRequest=(
self.messages.
RegionInstanceGroupManagersSetTemplateRequest(
instanceTemplate=template_ref.SelfLink(), )),
project=self.project,
region=igm_ref.region,
))
return [(service, self.method, request)]
def Run(self, args):
"""Returns a list of TargetPoolInstanceHealth objects."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
target_pool_ref = self.TARGET_POOL_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
target_pool = self.GetTargetPool(client, target_pool_ref)
instances = target_pool.instances
# If the target pool has no instances, we should return an empty
# list.
if not instances:
return
requests = []
for instance in instances:
request_message = client.messages.ComputeTargetPoolsGetHealthRequest(
instanceReference=client.messages.InstanceReference(
instance=instance),
project=target_pool_ref.project,
region=target_pool_ref.region,
targetPool=target_pool_ref.Name())
requests.append((client.apitools_client.targetPools, 'GetHealth',
request_message))
errors = []
resources = client.MakeRequests(requests=requests,
errors_to_collect=errors)
for resource in resources:
yield resource
if errors:
utils.RaiseToolException(
errors, error_message='Could not get health for some targets:')
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
igm_ref = (instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG.
ResolveAsResource)(
args, holder.resources,
default_scope=compute_scope.ScopeEnum.ZONE,
scope_lister=flags.GetDefaultScopeLister(client))
auto_healing_policies = (
managed_instance_groups_utils.CreateAutohealingPolicies(
holder.resources, client.messages, args))
if igm_ref.Collection() == 'compute.instanceGroupManagers':
service = client.apitools_client.instanceGroupManagers
request = (
client.messages.
ComputeInstanceGroupManagersSetAutoHealingPoliciesRequest(
project=igm_ref.project,
zone=igm_ref.zone,
instanceGroupManager=igm_ref.Name(),
instanceGroupManagersSetAutoHealingRequest=(
client.messages.InstanceGroupManagersSetAutoHealingRequest(
autoHealingPolicies=auto_healing_policies))))
else:
service = client.apitools_client.regionInstanceGroupManagers
request = (
client.messages.
ComputeRegionInstanceGroupManagersSetAutoHealingPoliciesRequest(
project=igm_ref.project,
region=igm_ref.region,
instanceGroupManager=igm_ref.Name(),
regionInstanceGroupManagersSetAutoHealingRequest=(
client.messages.
RegionInstanceGroupManagersSetAutoHealingRequest(
autoHealingPolicies=auto_healing_policies))))
return client.MakeRequests([(service, 'SetAutoHealingPolicies', request)])
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_ref = flags.INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
request = (
client.apitools_client.instances, 'GetShieldedInstanceIdentity',
client.messages.ComputeInstancesGetShieldedInstanceIdentityRequest(
instance=instance_ref.instance,
zone=instance_ref.zone,
project=instance_ref.project))
errors = []
objects = client.MakeRequests(requests=[request], errors_to_collect=errors)
if errors:
utils.RaiseToolException(
errors, error_message='Could not get Shielded identity:')
response = objects[0]
return response
def CreateGroupReference(self, args, client, resources):
if args.zones:
zone_ref = resources.Parse(
args.zones[0],
collection='compute.zones',
params={'project': properties.VALUES.core.project.GetOrFail})
region = utils.ZoneNameToRegionName(zone_ref.Name())
return resources.Parse(
args.name,
params={
'region': region,
'project': properties.VALUES.core.project.GetOrFail
},
collection='compute.regionInstanceGroupManagers')
group_ref = (instance_groups_flags.GetInstanceGroupManagerArg(
).ResolveAsResource)(args,
resources,
default_scope=compute_scope.ScopeEnum.ZONE,
scope_lister=flags.GetDefaultScopeLister(client))
if _IsZonalGroup(group_ref):
zonal_resource_fetcher = zone_utils.ZoneResourceFetcher(client)
zonal_resource_fetcher.WarnForZonalCreation([group_ref])
return group_ref
def _Run(args, holder, backend_bucket_arg, backend_service_arg, url_map_arg):
"""Issues requests necessary to create a Url Map."""
client = holder.client
url_map_ref = url_map_arg.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
if args.default_service:
default_backend_uri = url_maps_utils.ResolveUrlMapDefaultService(
args, backend_service_arg, url_map_ref,
holder.resources).SelfLink()
else:
default_backend_uri = backend_bucket_arg.ResolveAsResource(
args, holder.resources).SelfLink()
if url_maps_utils.IsGlobalUrlMapRef(url_map_ref):
return _MakeGlobalRequest(args, url_map_ref, default_backend_uri,
client)
elif url_maps_utils.IsRegionalUrlMapRef(url_map_ref):
return _MakeRegionalRequest(args, url_map_ref, default_backend_uri,
client)
def CreateRequests(self, args):
"""Returns a list of request necessary for setting scheduling options."""
instance_ref = instance_flags.INSTANCE_ARG.ResolveAsResource(
args,
self.resources,
scope_lister=flags.GetDefaultScopeLister(self.compute_client))
scheduling_options = self.messages.Scheduling()
scheduling_options.automaticRestart = args.restart_on_failure
if args.maintenance_policy:
scheduling_options.onHostMaintenance = (
self.messages.Scheduling.OnHostMaintenanceValueValuesEnum(
args.maintenance_policy))
request = self.messages.ComputeInstancesSetSchedulingRequest(
instance=instance_ref.Name(),
project=instance_ref.project,
scheduling=scheduling_options,
zone=instance_ref.zone)
return [request]
def _Run(args, track, enable_server_binding=False, enable_disk=False):
"""Creates a node template."""
holder = base_classes.ComputeApiHolder(track)
client = holder.client
node_template_ref = flags.MakeNodeTemplateArg().ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
messages = holder.client.messages
node_template = util.CreateNodeTemplate(node_template_ref,
args,
messages,
enable_server_binding,
enable_disk=enable_disk)
request = messages.ComputeNodeTemplatesInsertRequest(
nodeTemplate=node_template,
project=node_template_ref.project,
region=node_template_ref.region)
service = holder.client.apitools_client.nodeTemplates
return client.MakeRequests([(service, 'Insert', request)])[0]
def _Run(self, args, supports_network_tier=False, validate_beta_args=False):
"""Issues requests necessary to create Forwarding Rules."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
forwarding_rule_ref = self.FORWARDING_RULE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
if forwarding_rule_ref.Collection() == 'compute.globalForwardingRules':
requests = self._CreateGlobalRequests(client, holder.resources, args,
forwarding_rule_ref)
elif forwarding_rule_ref.Collection() == 'compute.forwardingRules':
requests = self._CreateRegionalRequests(
client,
holder.resources,
args,
forwarding_rule_ref,
supports_network_tier=supports_network_tier,
validate_beta_args=validate_beta_args)
return client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
router_ref = self.ROUTER_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
request = client.messages.ComputeRoutersGetNatMappingInfoRequest(
**router_ref.AsDict())
return list_pager.YieldFromList(
client.apitools_client.routers,
request,
limit=args.limit,
batch_size=args.page_size,
method='GetNatMappingInfo',
field='result',
current_token_attribute='pageToken',
next_token_attribute='nextPageToken',
batch_size_attribute='maxResults',
)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
messages = client.messages
neg_ref = flags.MakeNetworkEndpointGroupsArg().ResolveAsResource(
args, holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
args.filter, filter_expr = filter_rewrite.Rewriter().Rewrite(args.filter)
request = messages.ComputeNetworkEndpointGroupsListNetworkEndpointsRequest(
networkEndpointGroup=neg_ref.Name(),
project=neg_ref.project,
zone=neg_ref.zone,
filter=filter_expr)
return list_pager.YieldFromList(
client.apitools_client.networkEndpointGroups,
request,
method='ListNetworkEndpoints',
field='items',
limit=args.limit,
batch_size=None)
def _Run(args, holder, support_global_scope=False):
"""Issues the request necessary for adding the network endpoint group."""
client = holder.client
messages = holder.client.messages
resources = holder.resources
neg_client = network_endpoint_groups.NetworkEndpointGroupsClient(
client, messages, resources)
neg_ref = flags.MakeNetworkEndpointGroupsArg(
support_global_scope).ResolveAsResource(
args,
holder.resources,
default_scope=compute_scope.ScopeEnum.ZONE,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
_ValidateNEG(args, neg_ref)
result = neg_client.Create(neg_ref,
args.network_endpoint_type,
default_port=args.default_port,
network=args.network,
subnet=args.subnet)
log.CreatedResource(neg_ref.Name(), 'network endpoint group')
return result
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
messages = holder.client.messages
resources = holder.resources
pap_ref = flags.MakePublicAdvertisedPrefixesArg().ResolveAsResource(
args,
resources,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
pap_client = public_advertised_prefixes.PublicAdvertisedPrefixesClient(
client, messages, resources)
if self.support_pap_announce_withdraw:
if args.status is not None:
return pap_client.Patch(pap_ref, status=args.status)
if args.announce_prefix:
return pap_client.Announce(pap_ref)
if args.withdraw_prefix:
return pap_client.Withdraw(pap_ref)
else:
return pap_client.Patch(pap_ref, status=args.status)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_group_ref = Describe.ZonalInstanceGroupArg.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
request = client.messages.ComputeInstanceGroupsGetRequest(
**instance_group_ref.AsDict())
response = client.MakeRequests([(client.apitools_client.instanceGroups,
'Get', request)])[0]
return instance_groups_utils.ComputeInstanceGroupManagerMembership(
compute=client.apitools_client,
resources=holder.resources,
http=client.apitools_client.http,
batch_url=client.batch_url,
items=[encoding.MessageToDict(response)],
filter_mode=instance_groups_utils.InstanceGroupFilteringMode.
ALL_GROUPS)[0]
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
resource_arg = instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG
default_scope = compute_scope.ScopeEnum.ZONE
scope_lister = flags.GetDefaultScopeLister(client)
igm_ref = resource_arg.ResolveAsResource(args,
holder.resources,
default_scope=default_scope,
scope_lister=scope_lister)
template_ref = holder.resources.Parse(
args.template,
params={
'project': igm_ref.project,
},
collection='compute.instanceTemplates')
if self.ReleaseTrack() == base.ReleaseTrack.GA:
return self._MakeSetInstanceTemplateRequest(
client, igm_ref, template_ref)
return self._MakePatchRequest(client, igm_ref, template_ref)
def Run(self, args):
"""Issues requests necessary to update backend of the Backend Service."""
self._ValidateArgs(args)
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
backend_service_ref = (
flags.GLOBAL_REGIONAL_BACKEND_SERVICE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client)))
get_request = self._GetGetRequest(client, backend_service_ref)
backend_service = client.MakeRequests([get_request])[0]
modified_backend_service = self._Modify(
client, holder.resources, backend_service_ref, args, backend_service)
return client.MakeRequests([
self._GetSetRequest(client, backend_service_ref,
modified_backend_service)
])
def Run(self, args):
if self.ReleaseTrack() == base.ReleaseTrack.GA:
log.warning(
'The ssl-certificates delete command will soon require '
'either a --global or --region flag.')
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
ssl_certificate_refs = Delete.SSL_CERTIFICATE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(ssl_certificate_refs)
requests = []
for ssl_certificate_ref in ssl_certificate_refs:
requests.append(
(client.apitools_client.sslCertificates, 'Delete',
client.messages.ComputeSslCertificatesDeleteRequest(
**ssl_certificate_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
url_map_ref = self.URL_MAP_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
if args.default_service:
default_backend_uri = url_maps_utils.ResolveUrlMapDefaultService(
args, self.BACKEND_SERVICE_ARG, url_map_ref,
holder.resources).SelfLink()
else:
default_backend_uri = self.BACKEND_BUCKET_ARG.ResolveAsResource(
args, holder.resources).SelfLink()
if url_maps_utils.IsGlobalUrlMapRef(url_map_ref):
return self._MakeGlobalRequest(args, url_map_ref,
default_backend_uri, client)
elif url_maps_utils.IsRegionalUrlMapRef(url_map_ref):
return self._MakeRegionalRequest(args, url_map_ref,
default_backend_uri, client)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
node_template_ref = flags.MakeNodeTemplateArg().ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
console_io.PromptContinue(
'You are about to delete node template: [{}]'.format(
node_template_ref.Name()),
throw_if_unattended=True,
cancel_on_no=True)
messages = holder.client.messages
request = messages.ComputeNodeTemplatesDeleteRequest(
nodeTemplate=node_template_ref.Name(),
project=node_template_ref.project,
region=node_template_ref.region)
service = holder.client.apitools_client.nodeTemplates
return client.MakeRequests([(service, 'Delete', request)])
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
http_health_check_ref = self.HEALTH_CHECK_ARG.ResolveAsResource(
args, holder.resources)
target_pool_ref = self.TARGET_POOL_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
request = client.messages.ComputeTargetPoolsRemoveHealthCheckRequest(
region=target_pool_ref.region,
project=target_pool_ref.project,
targetPool=target_pool_ref.Name(),
targetPoolsRemoveHealthCheckRequest=(
client.messages.TargetPoolsRemoveHealthCheckRequest(
healthChecks=[client.messages.HealthCheckReference(
healthCheck=http_health_check_ref.SelfLink())])))
return client.MakeRequests([(client.apitools_client.targetPools,
'RemoveHealthCheck', request)])
def _Run(args, holder, url_map_arg):
"""Issues requests necessary to delete URL maps."""
client = holder.client
url_map_refs = url_map_arg.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(url_map_refs)
requests = []
for url_map_ref in url_map_refs:
if url_maps_utils.IsRegionalUrlMapRef(url_map_ref):
requests.append((client.apitools_client.regionUrlMaps, 'Delete',
client.messages.ComputeRegionUrlMapsDeleteRequest(
**url_map_ref.AsDict())))
else:
requests.append((client.apitools_client.urlMaps, 'Delete',
client.messages.ComputeUrlMapsDeleteRequest(
**url_map_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client.apitools_client
messages = holder.client.messages
image_ref = self.DISK_IMAGE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetDefaultScopeLister(holder.client))
add_labels = labels_util.GetUpdateLabelsDictFromArgs(args)
image = client.images.Get(
messages.ComputeImagesGetRequest(**image_ref.AsDict()))
replacement = labels_util.UpdateLabels(
image.labels,
messages.GlobalSetLabelsRequest.LabelsValue,
update_labels=add_labels)
if not replacement:
return image
request = messages.ComputeImagesSetLabelsRequest(
project=image_ref.project,
resource=image_ref.image,
globalSetLabelsRequest=messages.GlobalSetLabelsRequest(
labelFingerprint=image.labelFingerprint, labels=replacement))
operation = client.images.SetLabels(request)
operation_ref = holder.resources.Parse(
operation.selfLink, collection='compute.globalOperations')
operation_poller = poller.Poller(client.images)
return waiter.WaitFor(
operation_poller, operation_ref,
'Updating labels of image [{0}]'.format(image_ref.Name()))
def Run(self, args):
"""Issues API requests to update a VPN Tunnel.
Args:
args: argparse.Namespace, The arguments received by this command.
Returns:
[protorpc.messages.Message], A list of responses returned
by the compute API.
"""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
messages = holder.client.messages
helper = vpn_tunnels_utils.VpnTunnelHelper(holder)
vpn_tunnel_ref = _VPN_TUNNEL_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(holder.client))
labels_diff = labels_util.Diff.FromUpdateArgs(args)
if not labels_diff.MayHaveUpdates():
raise calliope_exceptions.RequiredArgumentException(
'LABELS', 'At least one of --update-labels or '
'--remove-labels must be specified.')
vpn_tunnel = helper.Describe(vpn_tunnel_ref)
labels_update = labels_diff.Apply(
messages.RegionSetLabelsRequest.LabelsValue, vpn_tunnel.labels)
if not labels_update.needs_update:
return vpn_tunnel
operation_ref = helper.SetLabels(vpn_tunnel_ref,
vpn_tunnel.labelFingerprint,
labels_update.labels)
return helper.WaitForOperation(
vpn_tunnel_ref, operation_ref,
'Updating labels of VPN tunnel [{0}]'.format(
vpn_tunnel_ref.Name()))
