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()))