def CreateMachineTypeUri(args, compute_client, resource_parser, project, location, scope): """Create a machine type URI for given args and instance reference.""" machine_type = args.machine_type custom_cpu = args.custom_cpu custom_memory = args.custom_memory vm_type = getattr(args, 'custom_vm_type', None) ext = getattr(args, 'custom_extensions', None) # Setting the machine type machine_type_name = instance_utils.InterpretMachineType( machine_type=machine_type, custom_cpu=custom_cpu, custom_memory=custom_memory, ext=ext, vm_type=vm_type) # Check to see if the custom machine type ratio is supported instance_utils.CheckCustomCpuRamRatio(compute_client, project, location, machine_type_name) machine_type_uri = instance_utils.ParseMachineType(resource_parser, machine_type_name, project, location, scope) return machine_type_uri
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, self.project)) machine_type = instance_utils.InterpretMachineType( machine_type=args.machine_type, custom_cpu=args.custom_cpu, custom_memory=args.custom_memory) instance_utils.CheckCustomCpuRamRatio(self.compute_client, self.project, instance_ref.zone, machine_type) machine_type_uri = self.resources.Parse( machine_type, collection='compute.machineTypes', params={ 'zone': instance_ref.zone }).SelfLink() set_machine_type_request = self.messages.InstancesSetMachineTypeRequest( machineType=machine_type_uri) request = self.messages.ComputeInstancesSetMachineTypeRequest( instance=instance_ref.Name(), project=self.project, instancesSetMachineTypeRequest=set_machine_type_request, zone=instance_ref.zone) return (request, )
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 = flags.INSTANCE_ARG.ResolveAsResource( args, holder.resources, scope_lister=flags.GetInstanceZoneScopeLister(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), vm_type=getattr(args, 'custom_vm_type', 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 CreateRequests(self, args): """Returns a list of request necessary for setting scheduling options.""" instance_ref = self.CreateZonalReference(args.name, args.zone) machine_type = instance_utils.InterpretMachineType(args) instance_utils.CheckCustomCpuRamRatio(self, instance_ref.zone, machine_type) machine_type_uri = self.CreateZonalReference( machine_type, instance_ref.zone, resource_type='machineTypes').SelfLink() set_machine_type_request = self.messages.InstancesSetMachineTypeRequest( machineType=machine_type_uri) request = self.messages.ComputeInstancesSetMachineTypeRequest( instance=instance_ref.Name(), project=self.project, instancesSetMachineTypeRequest=set_machine_type_request, zone=instance_ref.zone) return (request, )
def CreateRequests(self, args): _ValidateDiskFlags(args) instance_utils.ValidateLocalSsdFlags(args) # TODO(user) drop test after CSEK goes GA if hasattr(args, 'csek_key_file'): self.csek_keys = csek_utils.CsekKeyStore.FromArgs(args) else: self.csek_keys = None if args.maintenance_policy: on_host_maintenance = ( self.messages.Scheduling.OnHostMaintenanceValueValuesEnum( args.maintenance_policy)) else: on_host_maintenance = None # Note: We always specify automaticRestart=False for preemptible VMs. This # makes sense, since no-restart-on-failure is defined as "store-true", and # thus can't be given an explicit value. Hence it either has its default # value (in which case we override it for convenience's sake to the only # setting that makes sense for preemptible VMs), or the user actually # specified no-restart-on-failure, the only usable setting. if args.preemptible: scheduling = self.messages.Scheduling( automaticRestart=False, onHostMaintenance=on_host_maintenance, preemptible=True) else: scheduling = self.messages.Scheduling( automaticRestart=args.restart_on_failure, onHostMaintenance=on_host_maintenance) service_accounts = self.CreateServiceAccountMessages(args) if args.tags: tags = self.messages.Tags(items=args.tags) else: tags = None metadata = metadata_utils.ConstructMetadataMessage( self.messages, metadata=args.metadata, metadata_from_file=args.metadata_from_file) # If the user already provided an initial Windows password and # username through metadata, then there is no need to check # whether the image or the boot disk is Windows. boot_disk_size_gb = utils.BytesToGb(args.boot_disk_size) utils.WarnIfDiskSizeIsTooSmall(boot_disk_size_gb, args.boot_disk_type) instance_refs = self.CreateZonalReferences(args.names, args.zone) # Check if the zone is deprecated or has maintenance coming. self.WarnForZonalCreation(instance_refs) network_interface = self.CreateNetworkInterfaceMessage( args, instance_refs) # The element at index i is the machine type URI for instance # i. We build this list here because we want to delay work that # requires API calls as much as possible. This leads to a better # user experience because the tool can fail fast upon a spelling # mistake instead of delaying the user by making API calls whose # purpose has already been rendered moot by the spelling mistake. machine_type_uris = [] # Setting the machine type machine_type_name = instance_utils.InterpretMachineType(args) for instance_ref in instance_refs: # Check to see if the custom machine type ratio is supported instance_utils.CheckCustomCpuRamRatio(self, instance_ref.zone, machine_type_name) machine_type_uris.append( self.CreateZonalReference( machine_type_name, instance_ref.zone, resource_type='machineTypes').SelfLink()) create_boot_disk = not _UseExistingBootDisk(args) if create_boot_disk: image_uri, _ = self.ExpandImageFlag(args, return_image_resource=False) else: image_uri = None # A list of lists where the element at index i contains a list of # disk messages that should be set for the instance at index i. disks_messages = [] # A mapping of zone to boot disk references for all existing boot # disks that are being attached. # TODO(user): Simplify this once resources.Resource becomes # hashable. existing_boot_disks = {} for instance_ref in instance_refs: persistent_disks, boot_disk_ref = ( self.CreatePersistentAttachedDiskMessages(args, instance_ref)) local_ssds = [ instance_utils.CreateLocalSsdMessage(self, x.get('device-name'), x.get('interface'), instance_ref.zone) for x in args.local_ssd or [] ] if create_boot_disk: boot_disk = self.CreateDefaultBootAttachedDiskMessage( args, boot_disk_size_gb, image_uri, instance_ref) persistent_disks = [boot_disk] + persistent_disks else: existing_boot_disks[boot_disk_ref.zone] = boot_disk_ref disks_messages.append(persistent_disks + local_ssds) requests = [] for instance_ref, machine_type_uri, disks in zip( instance_refs, machine_type_uris, disks_messages): requests.append( self.messages.ComputeInstancesInsertRequest( instance=self.messages.Instance( canIpForward=args.can_ip_forward, disks=disks, description=args.description, machineType=machine_type_uri, metadata=metadata, name=instance_ref.Name(), networkInterfaces=[network_interface], serviceAccounts=service_accounts, scheduling=scheduling, tags=tags, ), project=self.project, zone=instance_ref.zone)) return requests
def _CreateRequests(self, args, holder, compute_client, resource_parser, project, location, scope): # gcloud creates default values for some fields in Instance resource # when no value was specified on command line. # When --source-instance-template was specified, defaults are taken from # Instance Template and gcloud flags are used to override them - by default # fields should not be initialized. name_pattern = args.name_pattern instance_names = args.predefined_names or [] instance_count = args.count or len(instance_names) per_instance_props = encoding.DictToAdditionalPropertyMessage( {el: {} for el in instance_names}, compute_client.messages. BulkInsertInstanceResource.PerInstancePropertiesValue) location_policy = self.GetLocationPolicy(args, compute_client.messages) instance_min_count = instance_count if args.IsSpecified('min_count'): instance_min_count = args.min_count source_instance_template = self.GetSourceInstanceTemplate( args, resource_parser) skip_defaults = source_instance_template is not None scheduling = instance_utils.GetScheduling( args, compute_client, skip_defaults, support_node_affinity=False, support_min_node_cpu=self._support_min_node_cpu, support_host_error_timeout_seconds=self. _support_host_error_timeout_seconds, support_max_run_duration=self._support_max_run_duration) tags = instance_utils.GetTags(args, compute_client) labels = instance_utils.GetLabels(args, compute_client, instance_properties=True) metadata = instance_utils.GetMetadata(args, compute_client, skip_defaults) network_interfaces = create_utils.GetBulkNetworkInterfaces( args=args, resource_parser=resource_parser, compute_client=compute_client, holder=holder, project=project, location=location, scope=scope, skip_defaults=skip_defaults) create_boot_disk = not ( instance_utils.UseExistingBootDisk((args.disk or []) + (args.create_disk or []))) image_uri = create_utils.GetImageUri(args, compute_client, create_boot_disk, project, resource_parser) shielded_instance_config = create_utils.BuildShieldedInstanceConfigMessage( messages=compute_client.messages, args=args) confidential_vm = False if self._support_confidential_compute: confidential_instance_config = ( create_utils.BuildConfidentialInstanceConfigMessage( messages=compute_client.messages, args=args)) confidential_vm = (args.IsSpecified('confidential_compute') and args.confidential_compute) service_accounts = create_utils.GetProjectServiceAccount( args, project, compute_client, skip_defaults) boot_disk_size_gb = instance_utils.GetBootDiskSizeGb(args) disks = [] if create_utils.CheckSpecifiedDiskArgs(args=args, support_disks=False, skip_defaults=skip_defaults): # Disks in bulk insert should be in READ_ONLY mode for disk in args.disk or []: disk['mode'] = 'ro' disks = create_utils.CreateDiskMessages( args=args, project=project, location=location, scope=scope, compute_client=compute_client, resource_parser=resource_parser, image_uri=image_uri, create_boot_disk=create_boot_disk, boot_disk_size_gb=boot_disk_size_gb, support_kms=True, support_nvdimm=self._support_nvdimm, support_source_snapshot_csek=self. _support_source_snapshot_csek, support_boot_snapshot_uri=self._support_boot_snapshot_uri, support_image_csek=self._support_image_csek, support_create_disk_snapshots=self. _support_create_disk_snapshots, use_disk_type_uri=False) machine_type_name = None if instance_utils.CheckSpecifiedMachineTypeArgs(args, skip_defaults): machine_type_name = instance_utils.CreateMachineTypeName( args, confidential_vm) # Check to see if the custom machine type ratio is supported instance_utils.CheckCustomCpuRamRatio(compute_client, project, location, machine_type_name) can_ip_forward = instance_utils.GetCanIpForward(args, skip_defaults) guest_accelerators = create_utils.GetAcceleratorsForInstanceProperties( args=args, compute_client=compute_client) # Create an AdvancedMachineFeatures message if any arguments are supplied # that require one. advanced_machine_features = None if (args.enable_nested_virtualization is not None or args.threads_per_core is not None or (self._support_numa_node_count and args.numa_node_count is not None) or (self._support_visible_core_count and args.visible_core_count is not None) or args.enable_uefi_networking is not None): visible_core_count = args.visible_core_count if self._support_visible_core_count else None advanced_machine_features = ( instance_utils.CreateAdvancedMachineFeaturesMessage( compute_client.messages, args.enable_nested_virtualization, args.threads_per_core, args.numa_node_count if self._support_numa_node_count else None, visible_core_count, args.enable_uefi_networking)) parsed_resource_policies = [] resource_policies = getattr(args, 'resource_policies', None) if resource_policies: for policy in resource_policies: resource_policy_ref = maintenance_util.ParseResourcePolicyWithScope( resource_parser, policy, project=project, location=location, scope=scope) parsed_resource_policies.append(resource_policy_ref.Name()) display_device = None if self._support_display_device and args.IsSpecified( 'enable_display_device'): display_device = compute_client.messages.DisplayDevice( enableDisplay=args.enable_display_device) reservation_affinity = instance_utils.GetReservationAffinity( args, compute_client) instance_properties = compute_client.messages.InstanceProperties( canIpForward=can_ip_forward, description=args.description, disks=disks, guestAccelerators=guest_accelerators, labels=labels, machineType=machine_type_name, metadata=metadata, minCpuPlatform=args.min_cpu_platform, networkInterfaces=network_interfaces, serviceAccounts=service_accounts, scheduling=scheduling, tags=tags, resourcePolicies=parsed_resource_policies, shieldedInstanceConfig=shielded_instance_config, reservationAffinity=reservation_affinity, advancedMachineFeatures=advanced_machine_features) if self._support_secure_tags and args.secure_tags: instance_properties.secureTags = secure_tags_utils.GetSecureTags( args.secure_tags) if args.resource_manager_tags: ret_resource_manager_tags = resource_manager_tags_utils.GetResourceManagerTags( args.resource_manager_tags) if ret_resource_manager_tags is not None: properties_message = compute_client.messages.InstanceProperties instance_properties.resourceManagerTags = properties_message.ResourceManagerTagsValue( additionalProperties=[ properties_message.ResourceManagerTagsValue. AdditionalProperty(key=key, value=value) for key, value in sorted( six.iteritems(ret_resource_manager_tags)) ]) if self._support_display_device and display_device: instance_properties.displayDevice = display_device if self._support_confidential_compute and confidential_instance_config: instance_properties.confidentialInstanceConfig = confidential_instance_config if self._support_erase_vss and args.IsSpecified( 'erase_windows_vss_signature'): instance_properties.eraseWindowsVssSignature = args.erase_windows_vss_signature if self._support_post_key_revocation_action_type and args.IsSpecified( 'post_key_revocation_action_type'): instance_properties.postKeyRevocationActionType = arg_utils.ChoiceToEnum( args.post_key_revocation_action_type, compute_client.messages. Instance.PostKeyRevocationActionTypeValueValuesEnum) if args.IsSpecified('network_performance_configs'): instance_properties.networkPerformanceConfig = ( instance_utils.GetNetworkPerformanceConfig( args, compute_client)) bulk_instance_resource = compute_client.messages.BulkInsertInstanceResource( count=instance_count, instanceProperties=instance_properties, minCount=instance_min_count, perInstanceProperties=per_instance_props, sourceInstanceTemplate=source_instance_template, namePattern=name_pattern, locationPolicy=location_policy) if scope == compute_scopes.ScopeEnum.ZONE: instance_service = compute_client.apitools_client.instances request_message = compute_client.messages.ComputeInstancesBulkInsertRequest( bulkInsertInstanceResource=bulk_instance_resource, project=project, zone=location) elif scope == compute_scopes.ScopeEnum.REGION: instance_service = compute_client.apitools_client.regionInstances request_message = compute_client.messages.ComputeRegionInstancesBulkInsertRequest( bulkInsertInstanceResource=bulk_instance_resource, project=project, region=location) return instance_service, request_message