def Run(self, args):
"""Issues requests necessary to delete URL maps."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
url_map_refs = Delete.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:
requests.append((client.apitools_client.urlMaps, 'Delete',
client.messages.ComputeUrlMapsDeleteRequest(
**url_map_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
"""Issues requests necessary to delete Target Instances."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
target_instance_refs = Delete.TARGET_INSTANCE_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(target_instance_refs, 'zone')
requests = []
for target_instance_ref in target_instance_refs:
requests.append((client.apitools_client.targetInstances, 'Delete',
client.messages.ComputeTargetInstancesDeleteRequest(
**target_instance_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
target_https_proxy_refs = Delete.TARGET_HTTPS_PROXY_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(target_https_proxy_refs)
requests = []
for target_https_proxy_ref in target_https_proxy_refs:
requests.append(
(client.apitools_client.targetHttpsProxies, 'Delete',
client.messages.ComputeTargetHttpsProxiesDeleteRequest(
**target_https_proxy_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
target_vpn_gateway_refs = Delete.TARGET_VPN_GATEWAY_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(target_vpn_gateway_refs, 'region')
requests = []
for target_vpn_gateway_ref in target_vpn_gateway_refs:
requests.append(
(client.apitools_client.targetVpnGateways, 'Delete',
client.messages.ComputeTargetVpnGatewaysDeleteRequest(
**target_vpn_gateway_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
instance_template_refs = Delete.InstanceTemplateArg.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(instance_template_refs)
requests = []
for instance_template_ref in instance_template_refs:
requests.append(
(client.apitools_client.instanceTemplates, 'Delete',
client.messages.ComputeInstanceTemplatesDeleteRequest(
**instance_template_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
snapshot_refs = Delete.SnapshotArg.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(snapshot_refs)
requests = []
for snapshot_ref in snapshot_refs:
requests.append((client.apitools_client.snapshots, 'Delete',
client.messages.ComputeSnapshotsDeleteRequest(
project=snapshot_ref.project,
snapshot=snapshot_ref.snapshot)))
return client.MakeRequests(requests)
def Run(self, args):
"""Issues requests necessary to delete Routers."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
router_refs = Delete.ROUTER_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(router_refs, 'region')
requests = []
for router_ref in router_refs:
requests.append((client.apitools_client.routers, 'Delete',
client.messages.ComputeRoutersDeleteRequest(
**router_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
"""Issues requests necessary to delete HTTPS Health Checks."""
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
https_health_check_refs = Delete.HTTPS_HEALTH_CHECK_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(https_health_check_refs)
requests = []
for https_health_check_ref in https_health_check_refs:
requests.append((client.apitools_client.httpsHealthChecks, 'Delete',
client.messages.ComputeHttpsHealthChecksDeleteRequest(
**https_health_check_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
backend_bucket_refs = Delete.BACKEND_BUCKET_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(backend_bucket_refs)
requests = []
for backend_bucket_ref in backend_bucket_refs:
requests.append(
(client.apitools_client.backendBuckets, 'Delete',
client.messages.ComputeBackendBucketsDeleteRequest(
**backend_bucket_ref.AsDict())))
return client.MakeRequests(requests)
def CreateRequests(self, args):
"""Returns a list of delete request protobufs."""
delete_request_class = self.service.GetRequestType(self.method)
name_field = self.service.GetMethodConfig(
self.method).ordered_params[-1]
# pylint:disable=too-many-function-args
refs = self.reference_creator(args.names, args)
utils.PromptForDeletion(refs,
self.scope_name,
prompt_title=self.custom_prompt)
requests = []
for ref in refs:
request = delete_request_class(project=ref.project)
setattr(request, name_field, ref.Name())
self.ScopeRequest(ref, request)
requests.append(request)
return requests
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
helper = vpn_tunnels_utils.VpnTunnelHelper(holder)
vpn_tunnel_refs = _VPN_TUNNEL_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
utils.PromptForDeletion(vpn_tunnel_refs, 'region')
operation_refs = [helper.Delete(ref) for ref in vpn_tunnel_refs]
wait_message = 'Deleting VPN {}'.format(
('tunnels' if (len(operation_refs) > 1) else 'tunnel'))
operation_poller = DeleteBatchPoller(client,
client.apitools_client.vpnTunnels)
return waiter.WaitFor(operation_poller,
poller.OperationBatch(operation_refs),
wait_message)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
refs = []
for name in args.names:
refs.append(holder.resources.Parse(
name,
collection=self.Collection(),
params={
'project': properties.VALUES.core.project.GetOrFail,
'securityPolicy': args.security_policy
}))
utils.PromptForDeletion(refs)
requests = []
for ref in refs:
security_policy_rule = client.SecurityPolicyRule(
ref, compute_client=holder.client)
requests.extend(security_policy_rule.Delete(only_generate_request=True))
return holder.client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
disk_refs = Delete.disks_arg.ResolveAsResource(
args,
holder.resources,
default_scope=compute_scope.ScopeEnum.ZONE,
scope_lister=flags.GetDefaultScopeLister(holder.client))
scope_name = self._GetCommonScopeNameForRefs(disk_refs)
utils.PromptForDeletion(disk_refs,
scope_name=scope_name,
prompt_title=None)
requests = list(
self._CreateDeleteRequests(holder.client.apitools_client,
disk_refs))
return holder.client.MakeRequests(requests)
def _Run(holder, target_http_proxy_refs):
"""Issues requests necessary to delete Target HTTP Proxies."""
client = holder.client
utils.PromptForDeletion(target_http_proxy_refs)
requests = []
for target_http_proxy_ref in target_http_proxy_refs:
if target_http_proxies_utils.IsRegionalTargetHttpProxiesRef(
target_http_proxy_ref):
requests.append(
(client.apitools_client.regionTargetHttpProxies, 'Delete',
client.messages.ComputeRegionTargetHttpProxiesDeleteRequest(
**target_http_proxy_ref.AsDict())))
else:
requests.append(
(client.apitools_client.targetHttpProxies, 'Delete',
client.messages.ComputeTargetHttpProxiesDeleteRequest(
**target_http_proxy_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
refs = self._BACKEND_SERVICE_ARG.ResolveAsResource(
args,
holder.resources,
default_scope=backend_services_utils.GetDefaultScope())
utils.PromptForDeletion(refs)
requests = []
for ref in refs:
backend_service = client.BackendService(
ref, compute_client=holder.client)
requests.extend(backend_service.Delete(only_generate_request=True))
errors = []
resources = holder.client.MakeRequests(requests, errors)
if errors:
utils.RaiseToolException(errors)
return resources
def CreateRequests(self, args):
if args.owners:
names = self.GetOwnerAccounts(args.names)
else:
names = args.names
user_refs = [
self.clouduseraccounts_resources.Parse(
user, collection='clouduseraccounts.users') for user in names
]
utils.PromptForDeletion(user_refs)
requests = []
for user_ref in user_refs:
request = self.messages.ClouduseraccountsUsersDeleteRequest(
project=self.project, user=user_ref.Name())
requests.append(request)
return requests
def Run(self, args):
compute_holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
holder = base_classes.ComputeUserAccountsApiHolder(self.ReleaseTrack())
client = holder.client
group_refs = [
holder.resources.Parse(
group,
params={'project': properties.VALUES.core.project.GetOrFail},
collection='clouduseraccounts.groups') for group in args.names
]
utils.PromptForDeletion(group_refs)
requests = []
for group_ref in group_refs:
request = client.MESSAGES_MODULE.ClouduseraccountsGroupsDeleteRequest(
project=group_ref.project, groupName=group_ref.Name())
requests.append((client.groups, 'Delete', request))
return compute_holder.client.MakeRequests(requests)
def _Run(holder, service_attachment_refs):
"""Issues requests necessary to delete service attachments.
Args:
holder: the class that holds lazy initialized API client and resources.
service_attachment_refs: the list of references for service attachments that
need to be deleted.
Returns:
A list of responses. One response for each deletion request.
"""
client = holder.client
utils.PromptForDeletion(service_attachment_refs)
requests = []
for service_attachment_ref in service_attachment_refs:
requests.append((client.apitools_client.serviceAttachments, 'Delete',
client.messages.ComputeServiceAttachmentsDeleteRequest(
**service_attachment_ref.AsDict())))
return client.MakeRequests(requests)
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
refs = self.TARGET_TCP_PROXY_ARG.ResolveAsResource(
args, holder.resources)
utils.PromptForDeletion(refs)
client = holder.client.apitools_client
messages = holder.client.messages
requests = []
for ref in refs:
requests.append((client.targetTcpProxies, 'Delete',
messages.ComputeTargetTcpProxiesDeleteRequest(
project=ref.project,
targetTcpProxy=ref.Name())))
errors = []
resources = holder.client.MakeRequests(requests, errors)
if errors:
utils.RaiseToolException(errors)
return resources
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
host_refs = Delete.HOST_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=compute_flags.GetDefaultScopeLister(client))
custom_prompt = (
'The following hosts will be deleted. Deleting a host is '
'irreversible and any data on the host will be lost.')
utils.PromptForDeletion(host_refs, 'zone', prompt_title=custom_prompt)
requests = [
(client.apitools_client.hosts, 'Delete',
client.messages.ComputeHostsDeleteRequest(**host_ref.AsDict()))
for host_ref in host_refs
]
return client.MakeRequests(requests)
def CreateRequests(self, args):
"""Returns a list of delete messages for instance group managers."""
# pylint:disable=too-many-function-args
igm_refs = (instance_groups_flags.
MULTISCOPE_INSTANCE_GROUP_MANAGERS_ARG.ResolveAsResource)(
args,
self.resources,
default_scope=flags.ScopeEnum.ZONE,
scope_lister=flags.GetDefaultScopeLister(
self.compute_client, self.project))
scope_name = self._GetCommonScopeNameForRefs(igm_refs)
# Disable ability to mix zonal and regional MIG delete in one command.
# This is temporary workaround of missing functionality
# FIXME(b/32276307)
_RaiseIfMixZoneRegion(igm_refs)
utils.PromptForDeletion(igm_refs,
scope_name=scope_name,
prompt_title=None)
requests = []
for ref in igm_refs:
if ref.Collection() == 'compute.instanceGroupManagers':
service = self.compute.instanceGroupManagers
request = service.GetRequestType(self.method)(
instanceGroupManager=ref.Name(),
project=self.project,
zone=ref.zone)
else:
service = self.compute.regionInstanceGroupManagers
request = service.GetRequestType(self.method)(
instanceGroupManager=ref.Name(),
project=self.project,
region=ref.region)
requests.append((service, self.method, request))
return requests
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
project = properties.VALUES.core.project.Get(required=True)
igm_refs = (instance_groups_flags.
MULTISCOPE_INSTANCE_GROUP_MANAGERS_ARG.ResolveAsResource)(
args,
holder.resources,
default_scope=compute_scope.ScopeEnum.ZONE,
scope_lister=flags.GetDefaultScopeLister(
holder.client, project))
scope_name = self._GetCommonScopeNameForRefs(igm_refs)
utils.PromptForDeletion(igm_refs,
scope_name=scope_name,
prompt_title=None)
requests = list(
self._CreateDeleteRequests(holder.client.apitools_client,
igm_refs))
# Delete autoscalers first.
errors = []
resources = holder.client.MakeRequests(
self._GenerateAutoscalerDeleteRequests(holder,
project,
mig_requests=requests),
errors)
if errors:
utils.RaiseToolException(errors)
# Now delete instance group managers.
errors = []
resources += holder.client.MakeRequests(requests, errors)
if errors:
utils.RaiseToolException(errors)
return resources
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(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):
"""Issues requests necessary for deleting users."""
holder = base_classes.ComputeUserAccountsApiHolder(self.ReleaseTrack())
client = holder.client
if args.owners:
names = self.GetOwnerAccounts(client, args.names)
else:
names = args.names
user_refs = [
holder.resources.Parse(
user,
params={'project': properties.VALUES.core.project.GetOrFail},
collection='clouduseraccounts.users') for user in names
]
utils.PromptForDeletion(user_refs)
requests = []
for user_ref in user_refs:
request = client.MESSAGES_MODULE.ClouduseraccountsUsersDeleteRequest(
project=user_ref.project, user=user_ref.Name())
requests.append((client.users, 'Delete', request))
errors = []
responses = list(
request_helper.MakeRequests(
requests=requests,
http=client.http,
batch_url='https://www.googleapis.com/batch/',
errors=errors))
if errors:
utils.RaiseToolException(errors,
error_message='Could not fetch resource:')
return responses
def Run(self, args):
holder = base_classes.ComputeApiHolder(self.ReleaseTrack())
client = holder.client
refs = flags.INSTANCES_ARG.ResolveAsResource(
args,
holder.resources,
scope_lister=flags.GetInstanceZoneScopeLister(client))
msg = _INSTANCE_DELETE_PROMPT
if args.keep_disks != 'all':
msg += ' ' + _INSTANCE_DELETE_PROMPT_DISK_ADDENDUM
utils.PromptForDeletion(refs, scope_name='zone', prompt_title=msg)
if args.delete_disks or args.keep_disks:
instance_resources = self.GetInstances(refs, client)
disks_to_warn_for = []
set_auto_delete_requests = []
for ref, resource in zip(refs, instance_resources):
for disk in resource.disks:
# Determines whether the current disk needs to have its
# autoDelete parameter changed.
if not self.AutoDeleteMustBeChanged(args, disk):
continue
# At this point, we know that the autoDelete property of the
# disk must be changed. Since autoDelete is a boolean, we
# just negate it!
# Yay, computer science! :) :) :)
new_auto_delete = not disk.autoDelete
if new_auto_delete:
disks_to_warn_for.append(
holder.resources.Parse(disk.source,
collection='compute.disks',
params={'zone': ref.zone}))
set_auto_delete_requests.append(
(client.apitools_client.instances, 'SetDiskAutoDelete',
client.messages.
ComputeInstancesSetDiskAutoDeleteRequest(
autoDelete=new_auto_delete,
deviceName=disk.deviceName,
instance=ref.Name(),
project=ref.project,
zone=ref.zone)))
if set_auto_delete_requests:
self.PromptIfDisksWithoutAutoDeleteWillBeDeleted(
disks_to_warn_for)
errors = []
client.MakeRequests(requests=set_auto_delete_requests,
errors_to_collect=errors)
if errors:
utils.RaiseToolException(
errors,
error_message=(
'Some requests to change disk auto-delete '
'behavior failed:'))
delete_requests = []
for ref in refs:
request_protobuf = client.messages.ComputeInstancesDeleteRequest(
**ref.AsDict())
delete_requests.append(
(client.apitools_client.instances, 'Delete', request_protobuf))
return client.MakeRequests(delete_requests)
def CreateRequests(self, args):
refs = instance_flags.INSTANCES_ARG.ResolveAsResource(
args, self.resources, scope_lister=flags.GetDefaultScopeLister(
self.compute_client, self.project))
utils.PromptForDeletion(
refs,
scope_name='zone',
prompt_title=('The following instances will be deleted. Attached '
'disks configured to be auto-deleted will be deleted '
'unless they are attached to any other instances. '
'Deleting a disk is irreversible and any data on the '
'disk will be lost.'))
if args.delete_disks or args.keep_disks:
instance_resources = self.GetInstances(refs)
disks_to_warn_for = []
set_auto_delete_requests = []
for ref, resource in zip(refs, instance_resources):
for disk in resource.disks:
# Determines whether the current disk needs to have its
# autoDelete parameter changed.
if not self.AutoDeleteMustBeChanged(args, disk):
continue
# At this point, we know that the autoDelete property of the
# disk must be changed. Since autoDelete is a boolean, we
# just negate it!
# Yay, computer science! :) :) :)
new_auto_delete = not disk.autoDelete
if new_auto_delete:
disks_to_warn_for.append(self.resources.Parse(
disk.source, collection='compute.disks',
params={'zone': ref.zone}))
set_auto_delete_requests.append((
self.service,
'SetDiskAutoDelete',
self.messages.ComputeInstancesSetDiskAutoDeleteRequest(
autoDelete=new_auto_delete,
deviceName=disk.deviceName,
instance=ref.Name(),
project=ref.project,
zone=ref.zone)))
if set_auto_delete_requests:
self.PromptIfDisksWithoutAutoDeleteWillBeDeleted(disks_to_warn_for)
errors = []
list(request_helper.MakeRequests(
requests=set_auto_delete_requests,
http=self.http,
batch_url=self.batch_url,
errors=errors,
custom_get_requests=None))
if errors:
utils.RaiseToolException(
errors,
error_message=('Some requests to change disk auto-delete '
'behavior failed:'))
delete_requests = []
for ref in refs:
request_protobuf = self.messages.ComputeInstancesDeleteRequest(
instance=ref.Name(),
zone=ref.zone,
project=ref.project)
delete_requests.append(request_protobuf)
return delete_requests
