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