def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client.apitools_client messages = holder.client.messages forwarding_rule_ref = self.FORWARDING_RULE_ARG.ResolveAsResource( args, holder.resources, scope_lister=compute_flags.GetDefaultScopeLister(holder.client)) update_labels = labels_util.GetUpdateLabelsDictFromArgs(args) remove_labels = labels_util.GetRemoveLabelsListFromArgs(args) if update_labels is None and remove_labels is None: raise calliope_exceptions.RequiredArgumentException( 'LABELS', 'At least one of --update-labels or ' '--remove-labels must be specified.') if forwarding_rule_ref.Collection() == 'compute.globalForwardingRules': forwarding_rule = client.globalForwardingRules.Get( messages.ComputeGlobalForwardingRulesGetRequest( **forwarding_rule_ref.AsDict())) labels_value = messages.GlobalSetLabelsRequest.LabelsValue else: forwarding_rule = client.forwardingRules.Get( messages.ComputeForwardingRulesGetRequest( **forwarding_rule_ref.AsDict())) labels_value = messages.RegionSetLabelsRequest.LabelsValue replacement = labels_util.UpdateLabels( forwarding_rule.labels, labels_value, update_labels=update_labels, remove_labels=remove_labels) if not replacement: return forwarding_rule if forwarding_rule_ref.Collection() == 'compute.globalForwardingRules': request = self._CreateGlobalSetLabelsRequest( messages, forwarding_rule_ref, forwarding_rule, replacement) operation = client.globalForwardingRules.SetLabels(request) operation_ref = holder.resources.Parse( operation.selfLink, collection='compute.globalOperations') operation_poller = poller.Poller(client.globalForwardingRules) else: request = self._CreateRegionalSetLabelsRequest( messages, forwarding_rule_ref, forwarding_rule, replacement) operation = client.forwardingRules.SetLabels(request) operation_ref = holder.resources.Parse( operation.selfLink, collection='compute.regionOperations') operation_poller = poller.Poller(client.forwardingRules) return waiter.WaitFor(operation_poller, operation_ref, 'Updating labels of forwarding rule [{0}]'.format( forwarding_rule_ref.Name()))
def _Run(self, args, support_user_licenses=False): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client.apitools_client messages = holder.client.messages disk_ref = self.DISK_ARG.ResolveAsResource( args, holder.resources, scope_lister=flags.GetDefaultScopeLister(holder.client)) disk_info = api_util.GetDiskInfo(disk_ref, client, messages) service = disk_info.GetService() if support_user_licenses and args.IsSpecified( 'zone') and _UserLicensesFlagsIncluded(args): disk_res = messages.Disk(name=disk_ref.Name()) if args.IsSpecified('update_user_licenses'): disk_res.userLicenses = args.update_user_licenses disk_update_request = messages.ComputeDisksUpdateRequest( project=disk_ref.project, disk=disk_ref.Name(), diskResource=disk_res, zone=disk_ref.zone, paths=['userLicenses']) update_operation = service.Update(disk_update_request) update_operation_ref = holder.resources.Parse( update_operation.selfLink, collection=disk_info.GetOperationCollection()) update_operation_poller = poller.Poller(service) result = waiter.WaitFor( update_operation_poller, update_operation_ref, 'Updating user licenses of disk [{0}]'.format(disk_ref.Name())) if not _LabelsFlagsIncluded(args): return result labels_diff = labels_util.GetAndValidateOpsFromArgs(args) disk = disk_info.GetDiskResource() set_label_req = disk_info.GetSetLabelsRequestMessage() labels_update = labels_diff.Apply(set_label_req.LabelsValue, disk.labels) request = disk_info.GetSetDiskLabelsRequestMessage( disk, labels_update.GetOrNone()) if not labels_update.needs_update: return disk operation = service.SetLabels(request) operation_ref = holder.resources.Parse( operation.selfLink, collection=disk_info.GetOperationCollection()) operation_poller = poller.Poller(service) return waiter.WaitFor( operation_poller, operation_ref, 'Updating labels of disk [{0}]'.format(disk_ref.Name()))
def Run(self, args): """Issues requests necessary to update Container.""" holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client instance_ref = instances_flags.INSTANCE_ARG.ResolveAsResource( args, holder.resources, scope_lister=instances_flags.GetInstanceZoneScopeLister(client)) # fetch the Instance resource instance = client.apitools_client.instances.Get( client.messages.ComputeInstancesGetRequest( **instance_ref.AsDict())) # find gce-container-declaration metadata entry for metadata in instance.metadata.items: if metadata.key == containers_utils.GCE_CONTAINER_DECLARATION: # update gce-container-declaration containers_utils.UpdateMetadata(metadata, args) # update Google Compute Engine resource operation = client.apitools_client.instances.SetMetadata( client.messages.ComputeInstancesSetMetadataRequest( metadata=instance.metadata, **instance_ref.AsDict())) operation_ref = holder.resources.Parse( operation.selfLink, collection='compute.zoneOperations') operation_poller = poller.Poller( client.apitools_client.instances) waiter.WaitFor( operation_poller, operation_ref, 'Updating specification of container [{0}]'.format( instance_ref.Name())) # restart the Virtual Machine operation = client.apitools_client.instances.Reset( client.messages.ComputeInstancesResetRequest( **instance_ref.AsDict())) operation_ref = holder.resources.Parse( operation.selfLink, collection='compute.zoneOperations') operation_poller = poller.Poller( client.apitools_client.instances) return waiter.WaitFor( operation_poller, operation_ref, 'Restarting container [{0}]'.format(instance_ref.Name())) raise containers_utils.NoGceContainerDeclarationMetadataKey()
def Run(self, args): """Issues the request to delete Signed URL key from the backend bucket.""" holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) api_client = holder.client.apitools_client messages = holder.client.messages service = api_client.backendServices backend_service_ref = flags.GLOBAL_BACKEND_SERVICE_ARG.ResolveAsResource( args, holder.resources, scope_lister=compute_flags.GetDefaultScopeLister(holder.client)) request = messages.ComputeBackendServicesDeleteSignedUrlKeyRequest( project=backend_service_ref.project, backendService=backend_service_ref.Name(), keyName=args.key_name) operation = service.DeleteSignedUrlKey(request) operation_ref = holder.resources.Parse( operation.selfLink, collection='compute.globalOperations') operation_poller = poller.Poller(service) return waiter.WaitFor( operation_poller, operation_ref, 'Deleting Cloud CDN Signed URL key from [{0}]'.format( backend_service_ref.Name()))
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.Diff(additions=add_labels).Apply( messages.GlobalSetLabelsRequest.LabelsValue, image.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 the request to add Signed URL key to the backend service.""" holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) api_client = holder.client.apitools_client messages = holder.client.messages service = api_client.backendBuckets backend_bucket_ref = self.BACKEND_BUCKET_ARG.ResolveAsResource( args, holder.resources, scope_lister=compute_flags.GetDefaultScopeLister(holder.client)) key_value = files.ReadFileContents(args.key_file).rstrip() request = messages.ComputeBackendBucketsAddSignedUrlKeyRequest( project=backend_bucket_ref.project, backendBucket=backend_bucket_ref.Name(), signedUrlKey=messages.SignedUrlKey(keyName=args.key_name, keyValue=key_value)) operation = service.AddSignedUrlKey(request) operation_ref = holder.resources.Parse( operation.selfLink, collection='compute.globalOperations') operation_poller = poller.Poller(service) return waiter.WaitFor( operation_poller, operation_ref, 'Adding Cloud CDN Signed URL key to [{0}]'.format( backend_bucket_ref.Name()))
def Run(self, args): instance_groups_flags.ValidateMigStatefulFlagsForInstanceConfigs( args, need_disk_source=True) holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client resources = holder.resources igm_ref = ( instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG. ResolveAsResource)( args, resources, scope_lister=compute_flags.GetDefaultScopeLister(client)) instance_ref = self._CreateNewInstanceReference( holder=holder, igm_ref=igm_ref, instance_name=args.instance) per_instance_config_message = ( instance_configs_messages.CreatePerInstanceConfigMessage)( holder, instance_ref, args.stateful_disk, args.stateful_metadata, disk_getter=NonExistentDiskGetter()) operation_ref, service = instance_configs_messages.CallCreateInstances( holder=holder, igm_ref=igm_ref, per_instance_config_message=per_instance_config_message) operation_poller = poller.Poller(service) create_result = waiter.WaitFor(operation_poller, operation_ref, 'Creating instance.') return create_result
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client.apitools_client messages = holder.client.messages disk_ref = self.DISK_ARG.ResolveAsResource( args, holder.resources, scope_lister=flags.GetDefaultScopeLister(holder.client)) update_labels, remove_labels = labels_util.GetAndValidateOpsFromArgs(args) service = self.GetDisksService(disk_ref, client) disk = service.Get(self.GetDiskGetRequest(disk_ref, messages)) set_labels_request = self.GetLabelsReplacementRequest( disk_ref, disk, messages, update_labels, remove_labels) if not set_labels_request: return disk operation = service.SetLabels(set_labels_request) operation_ref = holder.resources.Parse( operation.selfLink, collection=self.GetOperationCollection(disk_ref)) operation_poller = poller.Poller(service) return waiter.WaitFor( operation_poller, operation_ref, 'Updating labels of disk [{0}]'.format( disk_ref.Name()))
def WaitForOperation(resources, service, operation, backend_service_ref, message): """Waits for the backend service operation to finish. Args: resources: The resource parser. service: apitools.base.py.base_api.BaseApiService, the service representing the target of the operation. operation: The operation to wait for. backend_service_ref: The backend service reference. message: The message to show. Returns: The operation result. """ params = {'project': backend_service_ref.project} if backend_service_ref.Collection() == 'compute.regionBackendServices': collection = 'compute.regionOperations' params['region'] = backend_service_ref.region else: collection = 'compute.globalOperations' operation_ref = resources.Parse(operation.name, params=params, collection=collection) operation_poller = poller.Poller(service, backend_service_ref) return waiter.WaitFor(operation_poller, operation_ref, message)
def Update(self, neg_ref, add_endpoints=None, remove_endpoints=None): """Updates a Compute Network Endpoint Group.""" attach_endpoints_ref = None detach_endpoints_ref = None if add_endpoints: operation = self.AttachEndpoints(neg_ref, add_endpoints) attach_endpoints_ref = self._GetOperationsRef(operation) if remove_endpoints: operation = self.DetachEndpoints(neg_ref, remove_endpoints) detach_endpoints_ref = self._GetOperationsRef(operation) neg_name = neg_ref.Name() operation_poller = poller.Poller(self._service) result = None result = self._WaitForResult( operation_poller, attach_endpoints_ref, 'Attaching {0} endpoints to [{1}].'.format( len(add_endpoints) if add_endpoints else 0, neg_name)) or result result = self._WaitForResult( operation_poller, detach_endpoints_ref, 'Detaching {0} endpoints from [{1}].'.format( len(remove_endpoints) if remove_endpoints else 0, neg_name) ) or result return result
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client.apitools_client messages = holder.client.messages ips_ref = self.IPS_ARG.ResolveAsResource( args, holder.resources, scope_lister=flags.GetDefaultScopeLister(holder.client)) add_labels = labels_util.GetUpdateLabelsDictFromArgs(args) ips_info = api_util.GetInPlaceSnapshotInfo(ips_ref, client, messages) ips = ips_info.GetInPlaceSnapshotResource() set_label_req = ips_info.GetSetLabelsRequestMessage() labels_update = labels_util.Diff(additions=add_labels).Apply( set_label_req.LabelsValue, ips.labels) request = ips_info.GetSetInPlaceSnapshotLabelsRequestMessage( ips, labels_update.GetOrNone()) if not labels_update.needs_update: return ips service = ips_info.GetService() operation = service.SetLabels(request) operation_ref = holder.resources.Parse( operation.selfLink, collection=ips_info.GetOperationCollection()) operation_poller = poller.Poller(service) return waiter.WaitFor( operation_poller, operation_ref, 'Updating labels of in-place snapshot [{0}]'.format( ips_ref.Name()))
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client.apitools_client messages = holder.client.messages disk_ref = self.DISK_ARG.ResolveAsResource( args, holder.resources, scope_lister=flags.GetDefaultScopeLister(holder.client)) labels_diff = labels_util.GetAndValidateOpsFromArgs(args) disk_info = api_util.GetDiskInfo(disk_ref, client, messages) disk = disk_info.GetDiskResource() set_label_req = disk_info.GetSetLabelsRequestMessage() labels_update = labels_diff.Apply(set_label_req.LabelsValue, disk.labels) request = disk_info.GetSetDiskLabelsRequestMessage( disk, labels_update.GetOrNone()) if not labels_update.needs_update: return disk service = disk_info.GetService() operation = service.SetLabels(request) operation_ref = holder.resources.Parse( operation.selfLink, collection=disk_info.GetOperationCollection()) operation_poller = poller.Poller(service) return waiter.WaitFor( operation_poller, operation_ref, 'Updating labels of disk [{0}]'.format(disk_ref.Name()))
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client.apitools_client messages = holder.client.messages snapshot_ref = Update.SnapshotArg.ResolveAsResource( args, holder.resources) labels_diff = labels_util.GetAndValidateOpsFromArgs(args) snapshot = client.snapshots.Get( messages.ComputeSnapshotsGetRequest(**snapshot_ref.AsDict())) labels_update = labels_diff.Apply( messages.GlobalSetLabelsRequest.LabelsValue, snapshot.labels) if not labels_update.needs_update: return snapshot request = messages.ComputeSnapshotsSetLabelsRequest( project=snapshot_ref.project, resource=snapshot_ref.snapshot, globalSetLabelsRequest=messages.GlobalSetLabelsRequest( labelFingerprint=snapshot.labelFingerprint, labels=labels_update.labels)) operation = client.snapshots.SetLabels(request) operation_ref = holder.resources.Parse( operation.selfLink, collection='compute.globalOperations') operation_poller = poller.Poller(client.snapshots) return waiter.WaitFor( operation_poller, operation_ref, 'Updating labels of snapshot [{0}]'.format(snapshot_ref.Name()))
def _Patch(self, pdp_ref, resource): """Patches a public delegated prefix resource. Args: pdp_ref: resource reference. resource: PublicDelegatedPrefix resource. Returns: Operation result from the poller. """ # Drop all fields except fingerprint and modifiable ones. resource = self.messages.PublicDelegatedPrefix( fingerprint=resource.fingerprint, publicDelegatedSubPrefixs=resource.publicDelegatedSubPrefixs) include_fields = [] if not resource.publicDelegatedSubPrefixs: include_fields.append('publicDelegatedSubPrefixs') is_regional = hasattr(pdp_ref, 'region') if is_regional: request = self.messages.ComputePublicDelegatedPrefixesPatchRequest( publicDelegatedPrefix=pdp_ref.Name(), publicDelegatedPrefixResource=resource, project=pdp_ref.project, region=pdp_ref.region) with self.client.apitools_client.IncludeFields(include_fields): operation = self._regional_service.Patch(request) operation_ref = self.resources.Parse( operation.selfLink, collection='compute.regionOperations') operation_poller = poller.Poller(self._regional_service) else: request = self.messages.ComputeGlobalPublicDelegatedPrefixesPatchRequest( publicDelegatedPrefix=pdp_ref.Name(), publicDelegatedPrefixResource=resource, project=pdp_ref.project) with self.client.apitools_client.IncludeFields(include_fields): operation = self._global_service.Patch(request) operation_ref = self.resources.Parse( operation.selfLink, collection='compute.globalOperations') operation_poller = poller.Poller(self._global_service) return waiter.WaitFor( operation_poller, operation_ref, 'Updating public delegated prefix [{}].'.format(pdp_ref.Name()))
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) messages = holder.client.messages service = holder.client.apitools_client.networks network_ref = self.NETWORK_ARG.ResolveAsResource(args, holder.resources) if args.switch_to_custom_subnet_mode: prompt_msg = 'Network [{0}] will be switched to custom mode. '.format( network_ref.Name()) + 'This operation cannot be undone.' console_io.PromptContinue( message=prompt_msg, default=True, cancel_on_no=True) result = service.SwitchToCustomMode( messages.ComputeNetworksSwitchToCustomModeRequest( project=network_ref.project, network=network_ref.Name())) operation_ref = resources.REGISTRY.Parse( result.name, params={'project': network_ref.project}, collection='compute.globalOperations') if args.async_: log.UpdatedResource( operation_ref, kind='network {0}'.format(network_ref.Name()), is_async=True, details='Run the [gcloud compute operations describe] command ' 'to check the status of this operation.') return result operation_poller = poller.Poller(service, network_ref) return waiter.WaitFor(operation_poller, operation_ref, 'Switching network to custom-mode') network_resource = messages.Network() should_patch = False if getattr(args, 'mtu', None) is not None: network_resource.mtu = args.mtu should_patch = True if args.bgp_routing_mode or getattr(args, 'multicast_mode', None): should_patch = True if args.bgp_routing_mode: network_resource.routingConfig = messages.NetworkRoutingConfig() network_resource.routingConfig.routingMode = ( messages.NetworkRoutingConfig.RoutingModeValueValuesEnum( args.bgp_routing_mode.upper())) if getattr(args, 'multicast_mode', None): network_resource.multicastMode = ( messages.Network.MulticastModeValueValuesEnum( args.multicast_mode.upper())) if should_patch: resource = service.Patch( messages.ComputeNetworksPatchRequest( project=network_ref.project, network=network_ref.Name(), networkResource=network_resource)) return resource
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client.apitools_client messages = holder.client.messages disk_ref = self.DISK_ARG.ResolveAsResource( args, holder.resources, scope_lister=flags.GetDefaultScopeLister(holder.client)) add_labels = labels_util.GetUpdateLabelsDictFromArgs(args) if disk_ref.Collection() == 'compute.disks': service = client.disks request_type = messages.ComputeDisksGetRequest elif disk_ref.Collection() == 'compute.regionDisks': service = client.regionDisks request_type = messages.ComputeRegionDisksGetRequest else: raise ValueError('Unexpected resource argument of {}'.format( disk_ref.Collection())) disk = service.Get(request_type(**disk_ref.AsDict())) if disk_ref.Collection() == 'compute.disks': operation_collection = 'compute.zoneOperations' labels_update = labels_util.Diff(additions=add_labels).Apply( messages.ZoneSetLabelsRequest.LabelsValue, disk.labels) request = messages.ComputeDisksSetLabelsRequest( project=disk_ref.project, resource=disk_ref.disk, zone=disk_ref.zone, zoneSetLabelsRequest=messages.ZoneSetLabelsRequest( labelFingerprint=disk.labelFingerprint, labels=labels_update.GetOrNone())) else: operation_collection = 'compute.regionOperations' labels_update = labels_util.Diff(additions=add_labels).Apply( messages.RegionSetLabelsRequest.LabelsValue, disk.labels) request = messages.ComputeRegionDisksSetLabelsRequest( project=disk_ref.project, resource=disk_ref.disk, region=disk_ref.region, regionSetLabelsRequest=messages.RegionSetLabelsRequest( labelFingerprint=disk.labelFingerprint, labels=labels_update.GetOrNone())) if not labels_update.needs_update: return disk operation = service.SetLabels(request) operation_ref = holder.resources.Parse(operation.selfLink, collection=operation_collection) operation_poller = poller.Poller(service) return waiter.WaitFor( operation_poller, operation_ref, 'Updating labels of disk [{0}]'.format(disk_ref.Name()))
def Run(self, args): """See base.CreateCommand.""" holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) messages = holder.client.messages service = holder.client.apitools_client.routers router_ref = self.ROUTER_ARG.ResolveAsResource(args, holder.resources) request_type = messages.ComputeRoutersGetRequest replacement = service.Get(request_type(**router_ref.AsDict())) nat = nats_utils.CreateNatMessage( args, holder, with_rules=self.with_rules, with_tcp_time_wait_timeout=self.with_tcp_time_wait_timeout) replacement.nats.append(nat) result = service.Patch( messages.ComputeRoutersPatchRequest(project=router_ref.project, region=router_ref.region, router=router_ref.Name(), routerResource=replacement)) operation_ref = resources.REGISTRY.Parse( result.name, collection='compute.regionOperations', params={ 'project': router_ref.project, 'region': router_ref.region, }) if args.async_: log.CreatedResource( operation_ref, kind='nat [{0}] in router [{1}]'.format( nat.name, router_ref.Name()), is_async=True, details='Run the [gcloud compute operations describe] command ' 'to check the status of this operation.') return result target_router_ref = holder.resources.Parse( router_ref.Name(), collection='compute.routers', params={ 'project': router_ref.project, 'region': router_ref.region, }) operation_poller = poller.Poller(service, target_router_ref) return waiter.WaitFor( operation_poller, operation_ref, 'Creating NAT [{0}] in router [{1}]'.format( nat.name, router_ref.Name()))
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) messages = holder.client.messages service = holder.client.apitools_client.routers router_ref = self.ROUTER_ARG.ResolveAsResource(args, holder.resources) request_type = messages.ComputeRoutersGetRequest router = service.Get(request_type(**router_ref.AsDict())) rule_number = args.rule_number nat_name = args.nat nat = nats_utils.FindNatOrRaise(router, nat_name) rule = rules_utils.FindRuleOrRaise(nat, rule_number) rules_utils.UpdateRuleMessage(rule, args, holder, nat, with_private_nat=self.with_private_nat) result = service.Patch( messages.ComputeRoutersPatchRequest(project=router_ref.project, region=router_ref.region, router=router_ref.Name(), routerResource=router)) operation_ref = resources.REGISTRY.Parse( result.name, collection='compute.regionOperations', params={ 'project': router_ref.project, 'region': router_ref.region, }) if args.async_: log.UpdatedResource( operation_ref, kind='Rule [{0}] in NAT [{1}]'.format(rule_number, nat_name), is_async=True, details='Run the [gcloud compute operations describe] command ' 'to check the status of this operation.') return result target_router_ref = holder.resources.Parse( router_ref.Name(), collection='compute.routers', params={ 'project': router_ref.project, 'region': router_ref.region, }) operation_poller = poller.Poller(service, target_router_ref) return waiter.WaitFor( operation_poller, operation_ref, 'Updating Rule [{0}] in NAT [{1}]'.format(rule_number, nat_name))
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client resources = holder.resources igm_ref = ( instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG. ResolveAsResource)( args, resources, scope_lister=compute_flags.GetDefaultScopeLister(client), ) instance_ref = self._CreateInstanceReference( holder=holder, igm_ref=igm_ref, instance_name=args.instance) configs_getter = (instance_configs_getter. InstanceConfigsGetterWithSimpleCache)(client) configs_getter.check_if_instance_config_exists( igm_ref=igm_ref, instance_ref=instance_ref, should_exist=True) per_instance_config = configs_getter.get_instance_config( igm_ref=igm_ref, instance_ref=instance_ref) self._ValidateStatefulFlagsForInstanceConfigs(args, per_instance_config) per_instance_config_message = self._CombinePerInstanceConfigMessage( holder, per_instance_config, instance_ref, args) operation_ref = instance_configs_messages.CallPerInstanceConfigUpdate( holder=holder, igm_ref=igm_ref, per_instance_config_message=per_instance_config_message) if igm_ref.Collection() == 'compute.instanceGroupManagers': service = holder.client.apitools_client.instanceGroupManagers elif igm_ref.Collection() == 'compute.regionInstanceGroupManagers': service = holder.client.apitools_client.regionInstanceGroupManagers else: raise ValueError('Unknown reference type {0}'.format( igm_ref.Collection())) operation_poller = poller.Poller(service) update_result = waiter.WaitFor(operation_poller, operation_ref, 'Updating instance config.') if args.update_instance: apply_operation_ref = ( instance_configs_messages.CallApplyUpdatesToInstances)( holder=holder, igm_ref=igm_ref, instances=[six.text_type(instance_ref)], minimal_action=args.instance_update_minimal_action) return waiter.WaitFor(operation_poller, apply_operation_ref, 'Applying updates to instances.') return update_result
def Run(self, args): """Returns a request for moving a disk.""" holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) target_disk = Move.disk_arg.ResolveAsResource( args, holder.resources, scope_lister=flags.GetDefaultScopeLister(holder.client)) destination_zone = holder.resources.Parse( args.destination_zone, params={ 'project': properties.VALUES.core.project.GetOrFail, }, collection='compute.zones') client = holder.client.apitools_client messages = holder.client.messages request = messages.ComputeProjectsMoveDiskRequest( diskMoveRequest=messages.DiskMoveRequest( destinationZone=destination_zone.SelfLink(), targetDisk=target_disk.SelfLink(), ), project=target_disk.project, ) result = client.projects.MoveDisk(request) operation_ref = resources.REGISTRY.Parse( result.name, params={ 'project': properties.VALUES.core.project.GetOrFail, }, collection='compute.globalOperations') if args.async: log.UpdatedResource( operation_ref, kind='disk {0}'.format(target_disk.Name()), is_async=True, details='Run the [gcloud compute operations describe] command ' 'to check the status of this operation.' ) return result destination_disk_ref = holder.resources.Parse( target_disk.Name(), params={ 'project': destination_zone.project, 'zone': destination_zone.Name() }, collection='compute.disks') operation_poller = poller.Poller(client.disks, destination_disk_ref) return waiter.WaitFor( operation_poller, operation_ref, 'Moving disk {0}'.format(target_disk.Name()))
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client.apitools_client messages = holder.client.messages instance_ref = flags.INSTANCE_ARG.ResolveAsResource( args, holder.resources, scope_lister=flags.GetInstanceZoneScopeLister(holder.client)) result = None labels_operation_ref = None min_cpu_platform_operation_ref = None deletion_protection_operation_ref = None shielded_vm_config_ref = None labels_diff = labels_util.Diff.FromUpdateArgs(args) if labels_diff.MayHaveUpdates(): instance = client.instances.Get( messages.ComputeInstancesGetRequest(**instance_ref.AsDict())) result = instance labels_operation_ref = self._GetLabelsOperationRef( labels_diff, instance, instance_ref, holder) if hasattr(args, 'min_cpu_platform') and args.min_cpu_platform is not None: min_cpu_platform_operation_ref = self._GetMinCpuPlatformOperationRef( args.min_cpu_platform, instance_ref, holder) if args.deletion_protection is not None: deletion_protection_operation_ref = ( self._GetDeletionProtectionOperationRef( args.deletion_protection, instance_ref, holder)) operation_poller = poller.Poller(client.instances) result = self._WaitForResult(operation_poller, labels_operation_ref, 'Updating labels of instance [{0}]', instance_ref.Name()) or result result = self._WaitForResult( operation_poller, min_cpu_platform_operation_ref, 'Changing minimum CPU platform of instance [{0}]', instance_ref.Name()) or result result = self._WaitForResult( operation_poller, deletion_protection_operation_ref, 'Setting deletion protection of instance [{0}] to [{1}]', instance_ref.Name(), args.deletion_protection) or result if self.ReleaseTrack() == base.ReleaseTrack.ALPHA: if (hasattr(args, 'shielded_vm_secure_boot') or hasattr(args, 'shielded_vm_vtpm')): shielded_vm_config_ref = self._GetShieldedVMConfigRef( instance_ref, args, holder) result = self._WaitForResult( operation_poller, shielded_vm_config_ref, 'Setting shieldedVMConfig of instance [{0}]', instance_ref.Name()) or result return result
def WaitOperation(self, operation, operation_poller=None, message=None): if not operation_poller: operation_poller = poller.Poller( self._service, self.ref, has_project=self._api_has_project) if self._op_has_project and 'projects' not in operation.selfLink: operation.selfLink = operation.selfLink.replace('locations', 'projects/locations') operation_ref = self._resources.Parse( operation.selfLink, collection=OP_COLLECTION_NAME) return waiter.WaitFor(operation_poller, operation_ref, message)
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) messages = holder.client.messages service = holder.client.apitools_client.routers router_ref = self.ROUTER_ARG.ResolveAsResource(args, holder.resources) request_type = messages.ComputeRoutersGetRequest replacement = service.Get(request_type(**router_ref.AsDict())) # Retrieve specified NAT and update base fields. existing_nat = nats_utils.FindNatOrRaise(replacement, args.name) nat = nats_utils.UpdateNatMessage(existing_nat, args, holder, self.with_private_nat, self.with_subnet_all) request_type = messages.ComputeRoutersPatchRequest result = service.Patch( request_type(project=router_ref.project, region=router_ref.region, router=router_ref.Name(), routerResource=replacement)) operation_ref = resources.REGISTRY.Parse( result.name, collection='compute.regionOperations', params={ 'project': router_ref.project, 'region': router_ref.region, }) if args.async_: log.UpdatedResource( operation_ref, kind='nat [{0}] in router [{1}]'.format( nat.name, router_ref.Name()), is_async=True, details='Run the [gcloud compute operations describe] command ' 'to check the status of this operation.') return result target_router_ref = holder.resources.Parse( router_ref.Name(), collection='compute.routers', params={ 'project': router_ref.project, 'region': router_ref.region, }) operation_poller = poller.Poller(service, target_router_ref) return waiter.WaitFor( operation_poller, operation_ref, 'Updating nat [{0}] in router [{1}]'.format( nat.name, router_ref.Name()))
def _StartVm(holder, client, instance_ref): """Start the Virtual Machine.""" operation = client.apitools_client.instances.Start( client.messages.ComputeInstancesStartRequest(**instance_ref.AsDict())) operation_ref = holder.resources.Parse(operation.selfLink, collection='compute.zoneOperations') operation_poller = poller.Poller(client.apitools_client.instances) return waiter.WaitFor( operation_poller, operation_ref, 'Starting instance [{0}]'.format(instance_ref.Name()))
def Run(self, args): instance_groups_flags.ValidateMigStatefulFlagsForInstanceConfigs( args, for_update=True) holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client resources = holder.resources igm_ref = ( instance_groups_flags.MULTISCOPE_INSTANCE_GROUP_MANAGER_ARG. ResolveAsResource)( args, resources, scope_lister=compute_flags.GetDefaultScopeLister(client), ) instance_ref = self._CreateInstanceReference( holder=holder, igm_ref=igm_ref, instance_name=args.instance) configs_getter = (instance_configs_getter. InstanceConfigsGetterWithSimpleCache)(client) configs_getter.check_if_instance_config_exists( igm_ref=igm_ref, instance_ref=instance_ref, should_exist=True) per_instance_config_message = self._CombinePerInstanceConfigMessage( holder, configs_getter, igm_ref, instance_ref, args.update_stateful_disk, args.remove_stateful_disks, args.update_stateful_metadata, args.remove_stateful_metadata) operation_ref = instance_configs_messages.CallPerInstanceConfigUpdate( holder=holder, igm_ref=igm_ref, per_instance_config_message=per_instance_config_message) if igm_ref.Collection() == 'compute.instanceGroupManagers': service = holder.client.apitools_client.instanceGroupManagers else: service = holder.client.apitools_client.regionInstanceGroupManagers operation_poller = poller.Poller(service) update_result = waiter.WaitFor(operation_poller, operation_ref, 'Updating instance config.') if args.force_instance_update: apply_operation_ref = ( instance_configs_messages.CallApplyUpdatesToInstances)( holder=holder, igm_ref=igm_ref, instances=[str(instance_ref)]) return waiter.WaitFor(operation_poller, apply_operation_ref, 'Applying updates to instances.') return update_result
def UpdateInstance(holder, client, instance_ref, instance, args, container_mount_disk_enabled=False, container_mount_disk=None): """Update an instance and its container metadata.""" operation_poller = poller.Poller(client.apitools_client.instances) result = _UpdateShieldedInstanceConfig(holder, client, operation_poller, instance_ref, args) result = _SetShieldedInstanceIntegrityPolicy( holder, client, operation_poller, instance_ref, args) or result # find gce-container-declaration metadata entry for metadata in instance.metadata.items: if metadata.key == GCE_CONTAINER_DECLARATION: UpdateMetadata( holder, metadata, args, instance, container_mount_disk_enabled=container_mount_disk_enabled, container_mount_disk=container_mount_disk) # update Google Compute Engine resource operation = client.apitools_client.instances.SetMetadata( client.messages.ComputeInstancesSetMetadataRequest( metadata=instance.metadata, **instance_ref.AsDict())) operation_ref = holder.resources.Parse( operation.selfLink, collection='compute.zoneOperations') set_metadata_waiter = waiter.WaitFor( operation_poller, operation_ref, 'Updating specification of container [{0}]'.format( instance_ref.Name())) if (instance.status == client.messages.Instance.StatusValueValuesEnum.TERMINATED): return set_metadata_waiter or result elif (instance.status == client.messages.Instance.StatusValueValuesEnum.SUSPENDED): return _StopVm(holder, client, instance_ref) or result else: _StopVm(holder, client, instance_ref) return _StartVm(holder, client, instance_ref) or result raise NoGceContainerDeclarationMetadataKey()
def Run(self, args): """Issues API requests to update a Target 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()) client = holder.client.apitools_client messages = holder.client.messages target_vpn_gateway_ref = self.TARGET_VPN_GATEWAY_ARG.ResolveAsResource( args, holder.resources, scope_lister=compute_flags.GetDefaultScopeLister(holder.client)) update_labels = labels_util.GetUpdateLabelsDictFromArgs(args) remove_labels = labels_util.GetRemoveLabelsListFromArgs(args) if update_labels is None and remove_labels is None: raise calliope_exceptions.RequiredArgumentException( 'LABELS', 'At least one of --update-labels or ' '--remove-labels must be specified.') target_vpn_gateway = client.targetVpnGateways.Get( messages.ComputeTargetVpnGatewaysGetRequest( **target_vpn_gateway_ref.AsDict())) labels_value = messages.RegionSetLabelsRequest.LabelsValue replacement = labels_util.UpdateLabels( target_vpn_gateway.labels, labels_value, update_labels=update_labels, remove_labels=remove_labels) if not replacement: return target_vpn_gateway request = self._CreateRegionalSetLabelsRequest( messages, target_vpn_gateway_ref, target_vpn_gateway, replacement) operation = client.targetVpnGateways.SetLabels(request) operation_ref = holder.resources.Parse( operation.selfLink, collection='compute.regionOperations') operation_poller = poller.Poller(client.targetVpnGateways) return waiter.WaitFor(operation_poller, operation_ref, 'Updating labels of target VPN gateway [{0}]'.format( target_vpn_gateway_ref.Name()))
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) target_instance = flags.INSTANCE_ARG.ResolveAsResource( args, holder.resources, scope_lister=flags.GetInstanceZoneScopeLister(holder.client)) destination_zone = holder.resources.Parse( args.destination_zone, params={'project': target_instance.project}, collection='compute.zones') client = holder.client.apitools_client messages = holder.client.messages request = messages.ComputeProjectsMoveInstanceRequest( instanceMoveRequest=messages.InstanceMoveRequest( destinationZone=destination_zone.SelfLink(), targetInstance=target_instance.SelfLink(), ), project=target_instance.project, ) result = client.projects.MoveInstance(request) operation_ref = resources.REGISTRY.Parse( result.name, params={'project': target_instance.project}, collection='compute.globalOperations') if args.async_: log.UpdatedResource( operation_ref, kind='gce instance {0}'.format(target_instance.Name()), is_async=True, details='Use [gcloud compute operations describe] command ' 'to check the status of this operation.') return result destination_instance_ref = holder.resources.Parse( target_instance.Name(), collection='compute.instances', params={ 'project': target_instance.project, 'zone': destination_zone.Name() }) operation_poller = poller.Poller(client.instances, destination_instance_ref) return waiter.WaitFor( operation_poller, operation_ref, 'Moving gce instance {0}'.format(target_instance.Name()))
def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client.apitools_client messages = holder.client.messages instance_ref = instances_flags.INSTANCE_ARG.ResolveAsResource( args, holder.resources, scope_lister=flags.GetDefaultScopeLister(holder.client)) instance = client.instances.Get( messages.ComputeInstancesGetRequest(**instance_ref.AsDict())) for i in instance.networkInterfaces: if i.name == args.network_interface: fingerprint = i.fingerprint break else: raise exceptions.UnknownArgumentException( 'network-interface', 'Instance does not have a network interface [{}], ' 'present interfaces are [{}].'.format( args.network_interface, ', '.join([i.name for i in instance.networkInterfaces]))) patch_network_interface = messages.NetworkInterface( aliasIpRanges=( alias_ip_range_utils.CreateAliasIpRangeMessagesFromString( messages, True, args.aliases)), fingerprint=fingerprint) request = messages.ComputeInstancesUpdateNetworkInterfaceRequest( project=instance_ref.project, instance=instance_ref.instance, zone=instance_ref.zone, networkInterface=args.network_interface, networkInterfaceResource=patch_network_interface) cleared_fields = [] if not patch_network_interface.aliasIpRanges: cleared_fields.append('aliasIpRanges') with client.IncludeFields(cleared_fields): operation = client.instances.UpdateNetworkInterface(request) operation_ref = holder.resources.Parse( operation.selfLink, collection='compute.zoneOperations') operation_poller = poller.Poller(client.instances) return waiter.WaitFor( operation_poller, operation_ref, 'Updating network interface [{0}] of instance [{1}]'.format( args.network_interface, instance_ref.Name()))
def WaitForOperation(self, ssl_policy_ref, operation_ref, wait_message): """Waits for the specified operation to complete and returns the target. Args: ssl_policy_ref: The SSL policy reference object. operation_ref: The operation reference object to wait for. wait_message: String representing the wait message to display while the operation is in progress. Returns: The resulting resource object after the operation completes. """ operation_poller = poller.Poller(self._service, ssl_policy_ref) return waiter.WaitFor(operation_poller, operation_ref, wait_message)