# Copyright (c) 2017 Platform9 Systems Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either expressed or implied. See the # License for the specific language governing permissions and limitations # under the License. """Connection to the Google Cloud Platform - GCE service""" import hashlib import uuid import time import nova.conf from nova import exception from nova.image import glance from nova.i18n import _LI from nova.virt import driver, hardware from oslo_config import cfg from oslo_log import log as logging from nova.compute import task_states import gceutils from googleapiclient.errors import HttpError from nova.virt.gce.constants import GCE_STATE_MAP LOG = logging.getLogger(__name__) gce_group = cfg.OptGroup(name='GCE', title='Options to connect to Google cloud') gce_opts = [ cfg.StrOpt('service_key_path', help='Service key of GCE account', secret=True), cfg.StrOpt('zone', help='GCE region'), cfg.StrOpt('project_id', help='GCE project id'), cfg.IntOpt('vnc_port', default=5900, help='VNC starting port'), # 500 VCPUs cfg.IntOpt('max_vcpus', default=500, help='Max number of vCPUs that can be used'), # 1000 GB RAM cfg.IntOpt('max_memory_mb', default=1024000, help='Max memory MB that can be used'), # 1 TB Storage cfg.IntOpt('max_disk_gb', default=1024, help='Max storage in GB that can be used') ] CONF = nova.conf.CONF CONF.register_group(gce_group) CONF.register_opts(gce_opts, group=gce_group) DIAGNOSTIC_KEYS_TO_FILTER = ['group', 'block_device_mapping'] def set_nodes(nodes): """Sets GCE Driver's node.list. It has effect on the following methods: get_available_nodes() get_available_resource get_host_stats() To restore the change, call restore_nodes() """ global _GCE_NODES _GCE_NODES = nodes def restore_nodes(): """Resets GCE Driver's node list modified by set_nodes(). Usually called from tearDown(). """ global _GCE_NODES _GCE_NODES = [CONF.host] class GCEDriver(driver.ComputeDriver): capabilities = { "has_imagecache": True, "supports_recreate": True, } def __init__(self, virtapi, read_only=False): super(GCEDriver, self).__init__(virtapi) self.host_status_base = { 'vcpus': CONF.GCE.max_vcpus, 'memory_mb': CONF.GCE.max_memory_mb, 'local_gb': CONF.GCE.max_disk_gb, 'vcpus_used': 0, 'memory_mb_used': 0, 'local_gb_used': 0, 'hypervisor_type': 'GCE', 'hypervisor_version': '1.0', 'hypervisor_hostname': CONF.host, 'cpu_info': {}, 'disk_available_least': CONF.GCE.max_disk_gb, } self._mounts = {} self._interfaces = {} self._uuid_to_gce_instance = {} self.gce_zone = CONF.GCE.zone self.gce_project = CONF.GCE.project_id self.gce_svc_key = CONF.GCE.service_key_path def init_host(self, host): """ Initialize anything that is necessary for the driver to function """ self.gce_svc = gceutils.get_gce_service(self.gce_svc_key) self.gce_flavor_info = gceutils.get_machines_info( self.gce_svc, self.gce_project, self.gce_zone) LOG.info( _LI("GCE driver init with %s project, %s region") % (self.gce_project, self.gce_zone)) if '_GCE_NODES' not in globals(): set_nodes([CONF.host]) def _get_uuid_from_gce_id(self, gce_id): m = hashlib.md5() m.update(gce_id) return str(uuid.UUID(bytes=m.digest(), version=4)) def _get_gce_id_from_instance(self, instance): if 'gce_id' in instance.metadata and instance.metadata['gce_id']: return instance.metadata['gce_id'] elif instance.uuid in self._uuid_to_gce_instance: return self._uuid_to_gce_instance[instance.uuid]['name'] # if none of the conditions are met we cannot map OpenStack UUID to # GCE ID. raise exception.InstanceNotFound( 'Instance %s not found' % instance.uuid) def list_instances(self): """ Return the names of all the instances known to the virtualization layer, as a list. """ compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone all_instances = gceutils.list_instances(compute, project, zone) self._uuid_to_gce_instance.clear() instance_names = [] for instance in all_instances: if instance['status'] in [ "PROVISIONING", "STAGING", "STOPPING", "SUSPENDING", "TERMINATED" ]: continue openstack_id = gceutils.get_instances_metadata_key( compute, project, zone, instance, 'openstack_id') if openstack_id is None: openstack_id = self._get_uuid_from_gce_id(instance['name']) self._uuid_to_gce_instance[openstack_id] = instance instance_names.append(instance['name']) return instance_names def plug_vifs(self, instance, network_info): """Plug VIFs into networks.""" raise NotImplementedError() def unplug_vifs(self, instance, network_info): """Unplug VIFs from networks.""" raise NotImplementedError() def _process_network_info(self, network_info): if not network_info: raise exception.BuildAbortException('Network info missing') network_interfaces = [] for net_info in network_info: gce_network_name = 'net-' + net_info['network']['id'] gce_subnet_name = 'subnet-' + net_info['details']['subnet_id'] ip_address = net_info['details']['ip_address'] compute, project = self.gce_svc, self.gce_project gce_network_details = gceutils.get_network(compute, project, gce_network_name) for subnet_link in gce_network_details['subnetworks']: if gce_subnet_name in subnet_link: gce_subnet_link = subnet_link break network_interfaces.append({ 'network': gce_network_details['selfLink'], 'subnetwork': gce_subnet_link, 'networkIP': ip_address, }) # yapf:disable return network_interfaces def _process_ssh_keys(self, instance): key_name, key_data = instance.key_name, instance.key_data if key_name is None or key_data is None: return {} return { 'key': 'ssh-keys', 'value': '{0}:{1}'.format(key_name, key_data) } def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=None): """Create a new instance/VM/domain on the virtualization platform. Once this successfully completes, the instance should be running (power_state.RUNNING). If this fails, any partial instance should be completely cleaned up, and the virtualization platform should be in the state that it was before this call began. :param context: security context :param instance: nova.objects.instance.Instance This function should use the data there to guide the creation of the new instance. :param image_meta: image object returned by nova.image.glance that defines the image from which to boot this instance :param injected_files: User files to inject into instance. :param admin_password: set in instance. :param network_info: :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info` :param block_device_info: Information about block devices to be attached to the instance. """ compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone # GCE expects instance name in format "[a-z](?:[-a-z0-9]{0,61}[a-z0-9])?" # So we need to construct it for GCE from uuid gce_instance_name = 'inst-' + instance.uuid LOG.info( _LI("Creating instance %s as %s on GCE.") % (instance.display_name, gce_instance_name)) # Image Info image_link = instance.system_metadata['image_gce_link'] # Flavor Info flavor_name = instance.flavor.name flavor_link = "zones/%s/machineTypes/%s" % (self.gce_zone, flavor_name) # Network Info network_interfaces = self._process_network_info(network_info) # Create Instance operation = gceutils.create_instance(compute, project, zone, gce_instance_name, image_link, flavor_link, network_interfaces) gceutils.wait_for_operation(compute, project, operation) gce_instance = gceutils.get_instance(compute, project, zone, gce_instance_name) # Update GCE info in openstack instance metadata instance.metadata.update({'gce_id': gce_instance['name']}) gce_metadata = [ { 'key': 'openstack_id', 'value': instance.uuid }, ] ssh_keys = self._process_ssh_keys(instance) if ssh_keys: gce_metadata.append(ssh_keys) operation = gceutils.set_instance_metadata( compute, project, zone, gce_instance['name'], gce_metadata, operation='add') gceutils.wait_for_operation(compute, project, operation) self._uuid_to_gce_instance[instance.uuid] = gceutils.get_instance( compute, project, zone, gce_instance_name) def snapshot(self, context, instance, image_id, update_task_state): """Snapshot an image of the specified instance :param context: security context :param instance: nova.objects.instance.Instance :param image_id: Reference to a pre-created image holding the snapshot. Steps: 1. Find boot disk 2. Stop instance 3. Create temporary boot disk snapshot 4. Start instance 5. Create temporary disk from snapshot 6. Create image from disk 7. Add Image info to glance 8. Delete temporary disk 9. Delete temporary snapshot """ instance_stopped = False temp_disk_snapshot = False temp_disk_from_snapshot = False image_created = False compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone try: gce_id = self._get_gce_id_from_instance(instance) LOG.info(_LI("Taking snapshot of instance %s") % instance.uuid) try: boot_disk = gceutils.get_instance_boot_disk( compute, project, zone, gce_id) except AssertionError: reason = "Unable to find boot disk from instance metadata %s" % instance.uuid raise exception.InvalidMetadata(reason=reason) disk_name = boot_disk['name'] LOG.debug( _LI("1. Found boot disk %s for instance %s") % (disk_name, instance.uuid)) operation = gceutils.stop_instance(compute, project, zone, gce_id) gceutils.wait_for_operation(compute, project, operation) instance_stopped = True LOG.debug( _LI("2. Temporarily stopped instance %s") % instance.uuid) snapshot_name = 'novasnap-' + disk_name + time.strftime("%s") operation = gceutils.snapshot_disk( compute, project, zone, boot_disk['name'], snapshot_name) gceutils.wait_for_operation(compute, project, operation) temp_disk_snapshot = True LOG.debug(_LI("3. Created boot disk snapshot %s") % snapshot_name) operation = gceutils.start_instance(compute, project, zone, gce_id) gceutils.wait_for_operation(compute, project, operation) instance_stopped = False LOG.debug( _LI("4. Restart instance after disk snapshot %s") % instance.uuid) snapshot_disk_name = 'vol-' + snapshot_name operation = gceutils.create_disk_from_snapshot( compute, project, zone, snapshot_disk_name, snapshot_name) gceutils.wait_for_operation(compute, project, operation) snapshot_disk_info = gceutils.get_disk(compute, project, zone, snapshot_disk_name) temp_disk_from_snapshot = True LOG.debug( _LI("5. Created disk %s from snapshot %s") % (snapshot_disk_name, snapshot_name)) update_task_state(task_state=task_states.IMAGE_PENDING_UPLOAD) image_api = glance.get_default_image_service() image_data = image_api.show(context, image_id) name = image_data['name'] operation = gceutils.create_image_from_disk( compute, project, name, snapshot_disk_info['selfLink']) gceutils.wait_for_operation(compute, project, operation, timeout=120) image_created = True LOG.debug( _LI("6. Created image %s from disk %s") % (name, snapshot_disk_name)) LOG.info( _LI("Created GCE image %s from instance %s") % (name, instance.uuid)) update_task_state(task_state=task_states.IMAGE_UPLOADING, expected_state=task_states.IMAGE_PENDING_UPLOAD) gce_img_data = gceutils.get_image(compute, project, name) image_metadata = { 'name': name, 'container_format': 'bare', 'disk_format': 'raw', 'is_public': False, 'status': 'active', 'properties': { 'image_state': 'available', 'owner_id': instance.project_id, 'ramdisk_id': instance.ramdisk_id, 'location': 'gce://%s/%s/%s' % (project, name, image_id), 'gce_image_id': gce_img_data['id'], 'gce_link': gce_img_data['selfLink'], 'gce_size': gce_img_data['diskSizeGb'] }, } image_api.update(context, image_id, image_metadata) LOG.debug(_LI("7. Added image to glance %s") % name) disk_operation = gceutils.delete_disk(compute, project, zone, snapshot_disk_name) snap_operation = gceutils.delete_snapshot(compute, project, snapshot_name) gceutils.wait_for_operation(compute, project, disk_operation) temp_disk_from_snapshot = False LOG.debug(_LI("8. Delete temporary disk %s") % snapshot_disk_name) gceutils.wait_for_operation(compute, project, snap_operation) temp_disk_snapshot = False LOG.debug( _LI("9. Delete temporary disk snapshot %s") % snapshot_name) LOG.info(_LI("Completed snapshot for instance %s") % instance.uuid) except Exception as e: LOG.exception("An error occured during image creation: %s" % e) if instance_stopped: operation = gceutils.start_instance(compute, project, zone, gce_id) gceutils.wait_for_operation(compute, project, operation) LOG.debug( _LI("Restart instance after disk snapshot %s") % instance.uuid) if image_created: LOG.info( _LI("Rollback snapshot for instance %s, deleting image %s from GCE" ) % (instance.uuid, name)) operation = gceutils.delete_image(compute, project, name) gceutils.wait_for_operation(compute, project, operation) if temp_disk_from_snapshot: disk_operation = gceutils.delete_disk(compute, project, zone, snapshot_disk_name) gceutils.wait_for_operation(compute, project, disk_operation) LOG.debug( _LI("Rollback snapshot for instace %s, delete temporary disk %s" ) % (instance.uuid, snapshot_disk_name)) if temp_disk_snapshot: snap_operation = gceutils.delete_snapshot( compute, project, snapshot_name) gceutils.wait_for_operation(compute, project, snap_operation) LOG.debug( _LI("Rollback snapshot for instance %s, delete temporary disk snapshot %s" ) % (instance.uuid, snapshot_name)) raise e def reboot(self, context, instance, network_info, reboot_type, block_device_info=None, bad_volumes_callback=None): """ Reboot the specified instance. After this is called successfully, the instance's state goes back to power_state.RUNNING. The virtualization platform should ensure that the reboot action has completed successfully even in cases in which the underlying domain/vm is paused or halted/stopped. :param instance: nova.objects.instance.Instance :param network_info: :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info` :param reboot_type: Either a HARD or SOFT reboot :param block_device_info: Info pertaining to attached volumes :param bad_volumes_callback: Function to handle any bad volumes encountered """ if reboot_type == 'SOFT': self._soft_reboot(context, instance, network_info, block_device_info) elif reboot_type == 'HARD': self._hard_reboot(context, instance, network_info, block_device_info) def _soft_reboot(self, context, instance, network_info, block_device_info=None): compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone gce_id = self._get_gce_id_from_instance(instance) LOG.info(_LI('Stopping instance %s') % instance.uuid) operation = gceutils.stop_instance(compute, project, zone, gce_id) gceutils.wait_for_operation(compute, project, operation) LOG.info(_LI('Starting instance %s') % instance.uuid) operation = gceutils.start_instance(compute, project, zone, gce_id) gceutils.wait_for_operation(compute, project, operation) LOG.info(_LI('Soft Reboot Complete for instance %s') % instance.uuid) def _hard_reboot(self, context, instance, network_info, block_device_info=None): compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone gce_id = self._get_gce_id_from_instance(instance) LOG.info(_LI('Resetting instance %s') % instance.uuid) operation = gceutils.reset_instance(compute, project, zone, gce_id) gceutils.wait_for_operation(compute, project, operation) LOG.info(_LI('Hard Reboot Complete %s') % instance.uuid) @staticmethod def get_host_ip_addr(): """Retrieves the IP address of the host""" return CONF.my_ip def set_admin_password(self, instance, new_pass): """Set root password on specified instance""" raise NotImplementedError() def inject_file(self, instance, b64_path, b64_contents): raise NotImplementedError() def resume_state_on_host_boot(self, context, instance, network_info, block_device_info=None): raise NotImplementedError() def rescue(self, context, instance, network_info, image_meta, rescue_password): raise NotImplementedError() def unrescue(self, instance, network_info): raise NotImplementedError() def poll_rebooting_instances(self, timeout, instances): raise NotImplementedError() def migrate_disk_and_power_off(self, context, instance, dest, instance_type, network_info, block_device_info=None): raise NotImplementedError() def finish_revert_migration(self, context, instance, network_info, block_device_info=None, power_on=True): raise NotImplementedError() def post_live_migration_at_destination(self, context, instance, network_info, block_migration=False, block_device_info=None): raise NotImplementedError() def power_off(self, instance, timeout=0, retry_interval=0): """ Power off the specified instance. :param instance: nova.objects.instance.Instance :param timeout: time to wait for GuestOS to shutdown :param retry_interval: How often to signal guest while waiting for it to shutdown """ compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone gce_id = self._get_gce_id_from_instance(instance) LOG.info(_LI('Stopping instance %s') % instance.uuid) operation = gceutils.stop_instance(compute, project, zone, gce_id) gceutils.wait_for_operation(compute, project, operation) LOG.info(_LI('Power off complete %s') % instance.uuid) def power_on(self, context, instance, network_info, block_device_info): """Power on the specified instance.""" compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone gce_id = self._get_gce_id_from_instance(instance) LOG.info(_LI('Starting instance %s') % instance.uuid) operation = gceutils.start_instance(compute, project, zone, gce_id) gceutils.wait_for_operation(compute, project, operation) LOG.info(_LI("Power on Complete %s") % instance.uuid) def soft_delete(self, instance): """Deleting the specified instance""" LOG.info(_LI("Soft delete instance %s") % instance.uuid) self.destroy(instance) def restore(self, instance): raise NotImplementedError() def pause(self, instance): """ GCE doesn't support pause and cannot save system state and hence we've implemented the closest functionality which is to poweroff the instance. :param instance: nova.objects.instance.Instance """ LOG.info(_LI("Pause instance %s") % instance.uuid) self.power_off(instance) def unpause(self, instance): """ Since GCE doesn't support pause and cannot save system state, we had implemented the closest functionality which is to poweroff the instance. and powering on such an instance in this method. :param instance: nova.objects.instance.Instance """ LOG.info(_LI("Unpause instance %s") % instance.uuid) self.power_on(context=None, instance=instance, network_info=None, block_device_info=None) def suspend(self, context, instance): """ GCE doesn't support suspend and cannot save system state and hence we've implemented the closest functionality which is to poweroff the instance. :param instance: nova.objects.instance.Instance """ LOG.info(_LI("Suspending instance %s") % instance.uuid) self.power_off(instance) def resume(self, context, instance, network_info, block_device_info=None): """ Since GCE doesn't support resume and we cannot save system state, we've implemented the closest functionality which is to power on the instance. :param instance: nova.objects.instance.Instance """ LOG.info(_LI("Resuming instance %s") % instance.uuid) self.power_on(context, instance, network_info, block_device_info) def destroy(self, context, instance, network_info, block_device_info=None, destroy_disks=True, migrate_data=None): """Destroy the specified instance from the Hypervisor. If the instance is not found (for example if networking failed), this function should still succeed. It's probably a good idea to log a warning in that case. :param context: security context :param instance: Instance object as returned by DB layer. :param network_info: :py:meth:`~nova.network.manager.NetworkManager.get_instance_nw_info` :param block_device_info: Information about block devices that should be detached from the instance. :param destroy_disks: Indicates if disks should be destroyed :param migrate_data: implementation specific params """ compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone LOG.info(_LI('Deleting instance %s') % instance.uuid) try: gce_id = self._get_gce_id_from_instance(instance) except exception.InstanceNotFound: LOG.error( _LI("Unable to find GCE mapping for instance %s") % instance.uuid) return try: operation = gceutils.delete_instance(compute, project, zone, gce_id) except HttpError: # Sometimes instance may not exist in GCE, in that case we just # allow deleting VM from openstack LOG.error( _LI("Instance %s not found in GCE, removing from openstack.") % instance.uuid) return gceutils.wait_for_operation(compute, project, operation) LOG.info(_LI("Destroy Complete %s") % instance.uuid) def attach_volume(self, context, connection_info, instance, mountpoint, disk_bus=None, device_type=None, encryption=None): """Attach the disk to the instance at mountpoint using info. """ compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone gce_id = self._get_gce_id_from_instance(instance) gce_volume = connection_info['data'] disk_name = gce_volume['name'], disk_link = gce_volume['selfLink'] operation = gceutils.attach_disk(compute, project, zone, gce_id, disk_name, disk_link) gceutils.wait_for_operation(compute, project, operation) LOG.info( _LI("Volume %s attached to instace %s") % (disk_name, instance.uuid)) def detach_volume(self, connection_info, instance, mountpoint, encryption=None): """Detach the disk attached to the instance. """ compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone gce_id = self._get_gce_id_from_instance(instance) gce_volume = connection_info['data'] disk_name = gce_volume['name'] operation = gceutils.detach_disk(compute, project, zone, gce_id, disk_name) gceutils.wait_for_operation(compute, project, operation) LOG.info( _LI("Volume %s detached from instace %s") % (disk_name, instance.uuid)) def swap_volume(self, old_connection_info, new_connection_info, instance, mountpoint, resize_to): """Replace the disk attached to the instance. """ raise NotImplementedError() def attach_interface(self, instance, image_meta, vif): raise NotImplementedError() def detach_interface(self, instance, vif): raise NotImplementedError() def get_info(self, instance): """Get the current status of an instance, by name (not ID!) :param instance: nova.objects.instance.Instance object Returns a dict containing: :state: the running state, one of the power_state codes :max_mem: (int) the maximum memory in KBytes allowed :mem: (int) the memory in KBytes used by the domain :num_cpu: (int) the number of virtual CPUs for the domain :cpu_time: (int) the CPU time used in nanoseconds """ compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone gce_id = self._get_gce_id_from_instance(instance) gce_instance = gceutils.get_instance(compute, project, zone, gce_id) power_state = GCE_STATE_MAP[gce_instance['status']] gce_flavor = self.gce_flavor_info[instance.flavor.name] memory_mb = gce_flavor['memory_mb'] vcpus = gce_flavor['vcpus'] return hardware.InstanceInfo(state=power_state, max_mem_kb=memory_mb * 1024, mem_kb=memory_mb * 1024, num_cpu=vcpus, cpu_time_ns=0, id=instance.id) def allow_key(self, key): if key in DIAGNOSTIC_KEYS_TO_FILTER: return False return True def get_diagnostics(self, instance): """Return data about VM diagnostics.""" # Fake diagnostics return { 'cpu0_time': 17300000000, 'memory': 524288, 'vda_errors': -1, 'vda_read': 262144, 'vda_read_req': 112, 'vda_write': 5778432, 'vda_write_req': 488, 'vnet1_rx': 2070139, 'vnet1_rx_drop': 0, 'vnet1_rx_errors': 0, 'vnet1_rx_packets': 26701, 'vnet1_tx': 140208, 'vnet1_tx_drop': 0, 'vnet1_tx_errors': 0, 'vnet1_tx_packets': 662, } def get_all_bw_counters(self, instances): """Return bandwidth usage counters for each interface on each running VM. """ bw = [] return bw def get_all_volume_usage(self, context, compute_host_bdms): """Return usage info for volumes attached to vms on a given host. """ volusage = [] return volusage def block_stats(self, instance_name, disk_id): return [0L, 0L, 0L, 0L, None] def interface_stats(self, instance_name, iface_id): return [0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L] def get_vnc_console(self, context, instance): raise NotImplementedError() def get_spice_console(self, instance): """ Simple Protocol for Independent Computing Environments """ raise NotImplementedError() def get_console_pool_info(self, console_type): raise NotImplementedError() def refresh_provider_fw_rules(self): raise NotImplementedError() def get_available_resource(self, nodename): """Retrieve resource information. Updates compute manager resource info on ComputeNode table. This method is called when nova-compute launches and as part of a periodic task that records results in the DB. Without real hypervisor, pretend we have lots of disk and ram. :param nodename: node which the caller want to get resources from a driver that manages only one node can safely ignore this :returns: Dictionary describing resources """ if nodename not in _GCE_NODES: return {} dic = { 'vcpus': CONF.GCE.max_vcpus, 'memory_mb': CONF.GCE.max_memory_mb, 'local_gb': CONF.GCE.max_disk_gb, 'vcpus_used': 0, 'memory_mb_used': 0, 'local_gb_used': 0, 'hypervisor_type': 'GCE', 'hypervisor_version': '1', 'hypervisor_hostname': nodename, 'disk_available_least': 0, 'cpu_info': '?', 'numa_topology': None } supported_tuple = ('IA64', 'kvm', 'hvm') dic["supported_instances"] = [supported_tuple] return dic def ensure_filtering_rules_for_instance(self, instance_ref, network_info): return def get_instance_disk_info(self, instance_name): return def live_migration(self, context, instance_ref, dest, post_method, recover_method, block_migration=False, migrate_data=None): post_method(context, instance_ref, dest, block_migration, migrate_data) return def check_can_live_migrate_destination_cleanup(self, ctxt, dest_check_data): return def check_can_live_migrate_destination( self, ctxt, instance_ref, src_compute_info, dst_compute_info, block_migration=False, disk_over_commit=False): return {} def check_can_live_migrate_source(self, ctxt, instance_ref, dest_check_data): return def finish_migration(self, context, migration, instance, disk_info, network_info, image_meta, resize_instance, block_device_info=None, power_on=True): """Completes a resize :param migration: the migrate/resize information :param instance: nova.objects.instance.Instance being migrated/resized :param power_on: is True the instance should be powered on """ raise NotImplementedError() def confirm_migration(self, migration, instance, network_info): """Confirms a resize, destroying the source VM. :param instance: nova.objects.instance.Instance """ raise NotImplementedError() def pre_live_migration(self, context, instance_ref, block_device_info, network_info, disk, migrate_data=None): return def unfilter_instance(self, instance_ref, network_info): return def get_host_stats(self, refresh=False): """Return GCE Host Status of name, ram, disk, network.""" stats = [] for nodename in _GCE_NODES: host_status = self.host_status_base.copy() host_status['hypervisor_hostname'] = nodename host_status['host_hostname'] = nodename host_status['host_name_label'] = nodename host_status['hypervisor_type'] = 'Google-GCE' host_status['vcpus'] = CONF.GCE.max_vcpus host_status['memory_mb'] = CONF.GCE.max_memory_mb host_status['local_gb'] = CONF.GCE.max_disk_gb stats.append(host_status) if len(stats) == 0: raise exception.NovaException("GCE Driver has no node") elif len(stats) == 1: return stats[0] else: return stats def host_power_action(self, host, action): """Reboots, shuts down or powers up the host.""" return action def host_maintenance_mode(self, host, mode): """Start/Stop host maintenance window. On start, it triggers guest VMs evacuation. """ if not mode: return 'off_maintenance' return 'on_maintenance' def set_host_enabled(self, host, enabled): """Sets the specified host's ability to accept new instances.""" if enabled: return 'enabled' return 'disabled' def get_disk_available_least(self): raise NotImplementedError() def add_to_aggregate(self, context, aggregate, host, **kwargs): raise NotImplementedError() def remove_from_aggregate(self, context, aggregate, host, **kwargs): raise NotImplementedError() def get_volume_connector(self, instance): return {'ip': '127.0.0.1', 'initiator': 'GCE', 'host': 'GCEhost'} def get_available_nodes(self, refresh=False): return _GCE_NODES def instance_on_disk(self, instance): return False def list_instance_uuids(self, node=None, template_uuids=None, force=False): compute, project, zone = self.gce_svc, self.gce_project, self.gce_zone all_instances = gceutils.list_instances(compute, project, zone) self._uuid_to_gce_instance.clear() for instance in all_instances: if instance['status'] in [ "PROVISIONING", "STAGING", "STOPPING", "SUSPENDING", "TERMINATED" ]: continue openstack_id = gceutils.get_instances_metadata_key( compute, project, zone, instance, 'openstack_id') if openstack_id is None: openstack_id = self._get_uuid_from_gce_id(instance['name']) self._uuid_to_gce_instance[openstack_id] = instance return self._uuid_to_gce_instance.keys()