OpenStack Study: nova
OpenStack IndexPreviousNext
class CannotDeleteFile(DataObject):
def __init__(self):
class FileLocked(DataObject):
def __init__(self):
class VirtualDisk(DataObject):
def __init__(self, controllerKey=0, unitNumber=0):
class VirtualDiskFlatVer2BackingInfo(DataObject):
def __init__(self):
class VirtualDiskRawDiskMappingVer1BackingInfo(DataObject):
def __init__(self):
class VirtualIDEController(DataObject):
def __init__(self, key=0):
class VirtualLsiLogicController(DataObject):
def __init__(self, key=0, scsiCtlrUnitNumber=0):
class VirtualLsiLogicSASController(DataObject):
class VirtualPCNet32(DataObject):
def __init__(self):
class OptionValue(DataObject):
def __init__(self, key=None, value=None):
class VirtualMachine(ManagedObject):
def __init__(self, **kwargs):
def reconfig(self, factory, val):
class Network(ManagedObject):
def __init__(self):
class ResourcePool(ManagedObject):
def __init__(self, name="test_ResPool", value="resgroup-test"):
class DatastoreHostMount(DataObject):
def __init__(self, value='host-100'):
class ClusterComputeResource(ManagedObject):
def __init__(self, name="test_cluster"):
def _add_root_resource_pool(self, r_pool):
def _add_host(self, host_sys):
def _add_datastore(self, datastore):
def _update_summary(self):
class Datastore(ManagedObject):
def __init__(self, name="fake-ds", capacity=1024, free=500):
class HostNetworkSystem(ManagedObject):
def __init__(self, name="networkSystem"):
class HostStorageSystem(ManagedObject):
def __init__(self):
class HostSystem(ManagedObject):
def __init__(self, name="ha-host", connected=True, ds_ref=None):
def _add_iscsi_target(self, data):
def _add_port_group(self, spec):
class Datacenter(ManagedObject):
def __init__(self, name="ha-datacenter", ds_ref=None):
class Task(ManagedObject):
def __init__(self, task_name, state="running", result=None, error_fault=None):
def create_host_network_system():
def create_host_storage_system():
def create_host(ds_ref=None):
def create_datacenter(name, ds_ref=None):
def create_datastore(name, capacity, free):
def create_res_pool():
def create_network():
def create_cluster(name, ds_ref):
def create_task(task_name, state="running", result=None, error_fault=None):
def _add_file(file_path):
def _remove_file(file_path):
def fake_plug_vifs(*args, **kwargs):
def fake_get_network(*args, **kwargs):
def get_file(file_path):
def fake_fetch_image(context, image, instance, **kwargs):
def fake_upload_image(context, image, instance, **kwargs):
def fake_get_vmdk_size_and_properties(context, image_id, instance):
def _get_vm_mdo(vm_ref):
def _merge_extraconfig(existing, changes):
class FakeFactory(object):
def create(self, obj_name):
class FakeVim(object):
def __init__(self, protocol="https", host="localhost", trace=None):
def get_service_content(self):
def __repr__(self):
def __str__(self):
def _login(self):
def _logout(self):
def _terminate_session(self, *args, **kwargs):
def _check_session(self):
def _session_is_active(self, *args, **kwargs):
def _create_vm(self, method, *args, **kwargs):
def _reconfig_vm(self, method, *args, **kwargs):
def _create_copy_disk(self, method, vmdk_file_path):
def _extend_disk(self, method, size):
def _snapshot_vm(self, method):
def _find_all_by_uuid(self, *args, **kwargs):
def _delete_snapshot(self, method, *args, **kwargs):
def _delete_disk(self, method, *args, **kwargs):
def _delete_file(self, method, *args, **kwargs):
def _just_return(self):
def _just_return_task(self, method):
def _clone_vm(self, method, *args, **kwargs):
def _unregister_vm(self, method, *args, **kwargs):
def _search_ds(self, method, *args, **kwargs):
def _move_file(self, method, *args, **kwargs):
def _make_dir(self, method, *args, **kwargs):
def _set_power_state(self, method, vm_ref, pwr_state="poweredOn"):
def _retrieve_properties_continue(self, method, *args, **kwargs):
def _retrieve_properties_cancel(self, method, *args, **kwargs):
def _retrieve_properties(self, method, *args, **kwargs):
def _add_port_group(self, method, *args, **kwargs):
def _add_iscsi_send_tgt(self, method, *args, **kwargs):
def __getattr__(self, attr_name):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\host.py
class Host(object):
def __init__(self, session):
def host_power_action(self, host, action):
def host_maintenance_mode(self, host, mode):
def set_host_enabled(self, _host, enabled):
class HostState(object):
def __init__(self, session, host_name):
def get_host_stats(self, refresh=False):
def update_status(self):
class VCState(object):
def __init__(self, session, host_name, cluster):
def get_host_stats(self, refresh=False):
def update_status(self):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\imagecache.py
class ImageCacheManager(imagecache.ImageCacheManager):
def __init__(self, session, base_folder):
def _folder_delete(self, path, dc_ref):
def timestamp_folder_get(self, ds_path, image_id):
def timestamp_cleanup(self, dc_ref, ds_browser, ds_ref, ds_name, ds_path):
def _get_timestamp(self, ds_browser, ds_path):
def _get_timestamp_filename(self):
def _get_datetime_from_filename(self, timestamp_filename):
def _get_ds_browser(self, ds_ref):
def _list_datastore_images(self, ds_path, datastore):
def _age_cached_images(self, context, datastore, dc_info, ds_path):
def update(self, context, instances, datastores_info):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\io_util.py
class ThreadSafePipe(queue.LightQueue):
def __init__(self, maxsize, transfer_size):
def read(self, chunk_size):
def write(self, data):
def seek(self, offset, whence=0):
def tell(self):
def close(self):
class GlanceWriteThread(object):
def __init__(self, context, input, image_service, image_id, image_meta=None):
def start(self):
def _inner():
def stop(self):
def wait(self):
def close(self):
class IOThread(object):
def __init__(self, input, output):
def start(self):
def _inner():
def stop(self):
def wait(self):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\network_util.py
def get_network_with_the_name(session, network_name="vmnet0", cluster=None):
def get_vswitch_for_vlan_interface(session, vlan_interface, cluster=None):
def check_if_vlan_interface_exists(session, vlan_interface, cluster=None):
def get_vlanid_and_vswitch_for_portgroup(session, pg_name, cluster=None):
def create_port_group(session, pg_name, vswitch_name, vlan_id=0, cluster=None):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\read_write_util.py
class GlanceFileRead(object):
def __init__(self, glance_read_iter):
def read(self, chunk_size):
def get_next(self):
def close(self):
class VMwareHTTPFile(object):
def __init__(self, file_handle):
def set_eof(self, eof):
def get_eof(self):
def close(self):
def _build_vim_cookie_headers(self, vim_cookies):
def write(self, data):
def read(self, chunk_size):
def get_size(self):
class VMwareHTTPWriteFile(VMwareHTTPFile):
def __init__(self, host, data_center_name, datastore_name, cookies, file_path, file_size, scheme="https"):
def write(self, data):
def close(self):
class VMwareHTTPReadFile(VMwareHTTPFile):
def __init__(self, host, data_center_name, datastore_name, cookies, file_path, scheme="https"):
def read(self, chunk_size):
def get_size(self):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\vif.py
def _get_associated_vswitch_for_interface(session, interface, cluster=None):
def ensure_vlan_bridge(session, vif, cluster=None, create_vlan=True):
def _is_valid_opaque_network_id(opaque_id, bridge_id, integration_bridge, num_networks):
def _get_network_ref_from_opaque(opaque_networks, integration_bridge, bridge):
def get_neutron_network(session, network_name, cluster, vif):
def get_network_ref(session, cluster, vif, is_neutron):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\vim.py
def get_moref(value, type):
def object_to_dict(obj, list_depth=1):
class VIMMessagePlugin(suds.plugin.MessagePlugin):
def addAttributeForValue(self, node):
def marshalled(self, context):
class Vim:
def __init__(self, protocol="https", host="localhost"):
def retrieve_service_content(self):
def get_wsdl_url(protocol, host_name):
def get_soap_url(protocol, host_name):
def get_service_content(self):
def __getattr__(self, attr_name):
def vim_request_handler(managed_object, **kwargs):
def _request_managed_object_builder(self, managed_object):
def __repr__(self):
def __str__(self):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\vim_util.py
def build_selection_spec(client_factory, name):
def build_traversal_spec(client_factory, name, spec_type, path, skip, select_set):
def build_recursive_traversal_spec(client_factory):
def build_property_spec(client_factory, type="VirtualMachine", properties_to_collect=None, all_properties=False):
def build_object_spec(client_factory, root_folder, traversal_specs):
def build_property_filter_spec(client_factory, property_specs, object_specs):
def get_object_properties(vim, collector, mobj, type, properties):
def get_dynamic_property(vim, mobj, type, property_name):
def get_dynamic_properties(vim, mobj, type, property_names):
def get_objects(vim, type, properties_to_collect=None, all=False):
def get_inner_objects(vim, base_obj, path, inner_type, properties_to_collect=None, all=False):
def cancel_retrieve(vim, token):
def continue_to_get_objects(vim, token):
def get_prop_spec(client_factory, spec_type, properties):
def get_obj_spec(client_factory, obj, select_set=None):
def get_prop_filter_spec(client_factory, obj_spec, prop_spec):
def get_properties_for_a_collection_of_objects(vim, type, obj_list, properties):
def get_about_info(vim):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\vmops.py
class VMwareVMOps(object):
def __init__(self, session, virtapi, volumeops, cluster=None, datastore_regex=None):
def list_instances(self):
def _extend_virtual_disk(self, instance, requested_size, name, dc_ref):
def _delete_datastore_file(self, instance, datastore_path, dc_ref):
def _get_vmdk_path(self, ds_name, folder, name):
def _get_disk_format(self, image_meta):
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info, block_device_info=None, instance_name=None, power_on=True):
def _get_image_properties(root_size):
def _get_vif_infos():
def _execute_create_vm():
def _create_virtual_disk(virtual_disk_path, file_size_in_kb):
def _fetch_image_on_datastore(upload_name):
def _copy_virtual_disk(source, dest):
def _power_on_vm():
def _create_config_drive(self, instance, injected_files, admin_password, data_store_name, dc_name, upload_folder, cookies):
def _attach_cdrom_to_vm(self, vm_ref, instance, datastore, file_path):
def decide_linked_clone(image_linked_clone, global_linked_clone):
def get_copy_virtual_disk_spec(self, client_factory, adapter_type, disk_type):
def _create_vm_snapshot(self, instance, vm_ref):
def _delete_vm_snapshot(self, instance, vm_ref, snapshot):
def snapshot(self, context, instance, image_id, update_task_state):
def _get_vm_and_vmdk_attribs():
def _check_if_tmp_folder_exists():
def _copy_vmdk_content():
def _upload_vmdk_to_image_repository():
def _clean_temp_data():
def _get_values_from_object_properties(self, props, query):
def reboot(self, instance, network_info):
def _delete(self, instance, network_info):
def destroy(self, instance, network_info, destroy_disks=True, instance_name=None):
def pause(self, instance):
def unpause(self, instance):
def suspend(self, instance):
def resume(self, instance):
def rescue(self, context, instance, network_info, image_meta):
def unrescue(self, instance):
def power_off(self, instance):
def _power_on(self, instance, vm_ref=None):
def power_on(self, context, instance, network_info, block_device_info):
def _get_orig_vm_name_label(self, instance):
def _update_instance_progress(self, context, instance, step, total_steps):
def migrate_disk_and_power_off(self, context, instance, dest, flavor):
def confirm_migration(self, migration, instance, network_info):
def finish_revert_migration(self, context, instance, network_info, block_device_info, power_on=True):
def finish_migration(self, context, migration, instance, disk_info, network_info, image_meta, resize_instance=False, block_device_info=None, power_on=True):
def live_migration(self, context, instance_ref, dest, post_method, recover_method, block_migration=False):
def poll_rebooting_instances(self, timeout, instances):
def get_info(self, instance):
def _get_diagnostic_from_object_properties(self, props, wanted_props):
def get_diagnostics(self, instance):
def get_vnc_console(self, instance):
def get_vnc_console_vcenter(self, instance):
def _get_machine_id_str(network_info):
def _set_machine_id(self, client_factory, instance, network_info):
def _set_vnc_config(self, client_factory, instance, port):
def _get_ds_browser(self, ds_ref):
def get_datacenter_ref_and_name(self, ds_ref):
def _get_host_ref_from_name(self, host_name):
def _get_vmfolder_ref(self):
def _create_folder_if_missing(self, ds_name, ds_ref, folder):
def check_cache_folder(self, ds_name, ds_ref):
def check_temp_folder(self, ds_name, ds_ref):
def _check_if_folder_file_exists(self, ds_browser, ds_ref, ds_name, folder_name, file_name):
def inject_network_info(self, instance, network_info):
def manage_image_cache(self, context, instances):
def _get_valid_vms_from_retrieve_result(self, retrieve_result):
class VMwareVCVMOps(VMwareVMOps):
def get_copy_virtual_disk_spec(self, client_factory, adapter_type, disk_type):
def _update_datacenter_cache_from_objects(self, dcs):
def get_datacenter_ref_and_name(self, ds_ref):
def list_instances(self):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\vmware_images.py
def start_transfer(context, read_file_handle, data_size, write_file_handle=None, image_service=None, image_id=None, image_meta=None):
def upload_iso_to_datastore(iso_path, instance, **kwargs):
def fetch_image(context, image, instance, **kwargs):
def upload_image(context, image, instance, **kwargs):
def get_vmdk_size_and_properties(context, image, instance):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\vm_util.py
def vm_refs_cache_reset():
def vm_ref_cache_delete(id):
def vm_ref_cache_update(id, vm_ref):
def vm_ref_cache_get(id):
def _vm_ref_cache(id, func, session, data):
def vm_ref_cache_from_instance(func):
def vm_ref_cache_from_name(func):
def get_vm_create_spec(client_factory, instance, name, data_store_name, vif_infos, os_type="otherGuest"):
def get_vm_resize_spec(client_factory, instance):
def create_controller_spec(client_factory, key, adapter_type="lsiLogic"):
def create_network_spec(client_factory, vif_info):
def get_vmdk_attach_config_spec(client_factory, disk_type="preallocated", file_path=None, disk_size=None, linked_clone=False, controller_key=None, unit_number=None, device_name=None):
def get_cdrom_attach_config_spec(client_factory, datastore, file_path, controller_key, cdrom_unit_number):
def get_vmdk_detach_config_spec(client_factory, device, destroy_disk=False):
def get_vm_extra_config_spec(client_factory, extra_opts):
def get_vmdk_path_and_adapter_type(hardware_devices, uuid=None):
def _find_controller_slot(controller_keys, taken, max_unit_number):
def _is_ide_controller(device):
def _is_scsi_controller(device):
def _find_allocated_slots(devices):
def allocate_controller_key_and_unit_number(client_factory, devices, adapter_type):
def get_rdm_disk(hardware_devices, uuid):
def get_copy_virtual_disk_spec(client_factory, adapter_type="lsiLogic", disk_type="preallocated"):
def get_vmdk_create_spec(client_factory, size_in_kb, adapter_type="lsiLogic", disk_type="preallocated"):
def get_rdm_create_spec(client_factory, device, adapter_type="lsiLogic", disk_type="rdmp"):
def create_virtual_cdrom_spec(client_factory, datastore, controller_key, file_path, cdrom_unit_number):
def create_virtual_disk_spec(client_factory, controller_key, disk_type="preallocated", file_path=None, disk_size=None, linked_clone=False, unit_number=None, device_name=None):
def detach_virtual_disk_spec(client_factory, device, destroy_disk=False):
def clone_vm_spec(client_factory, location, power_on=False, snapshot=None, template=False, config=None):
def relocate_vm_spec(client_factory, datastore=None, host=None, disk_move_type="moveAllDiskBackingsAndAllowSharing"):
def get_dummy_vm_create_spec(client_factory, name, data_store_name):
def get_machine_id_change_spec(client_factory, machine_id_str):
def get_add_vswitch_port_group_spec(client_factory, vswitch_name, port_group_name, vlan_id):
def get_vnc_config_spec(client_factory, port):
def get_vnc_port(session):
def _get_allocated_vnc_ports(session):
def search_datastore_spec(client_factory, file_name):
def _get_token(results):
def _get_reference_for_value(results, value):
def _get_object_for_value(results, value):
def _get_object_for_optionvalue(results, value):
def _get_object_from_results(session, results, value, func):
def _cancel_retrieve_if_necessary(session, results):
def _get_vm_ref_from_name(session, vm_name):
def get_vm_ref_from_name(session, vm_name):
def _get_vm_ref_from_uuid(session, instance_uuid):
def _get_vm_ref_from_vm_uuid(session, instance_uuid):
def _get_vm_ref_from_extraconfig(session, instance_uuid):
def get_vm_ref(session, instance):
def search_vm_ref_by_identifier(session, identifier):
def get_host_ref_from_id(session, host_id, property_list=None):
def get_host_id_from_vm_ref(session, vm_ref):
def property_from_property_set(property_name, property_set):
def _property_from_propSet(propSet, name='name'):
def get_host_ref_for_vm(session, instance, props):
def get_host_name_for_vm(session, instance):
def get_host_name_from_host_ref(host_ref):
def get_vm_state_from_name(session, vm_name):
def get_stats_from_cluster(session, cluster):
def get_cluster_ref_from_name(session, cluster_name):
def get_host_ref(session, cluster=None):
def propset_dict(propset):
def _select_datastore(data_stores, best_match, datastore_regex=None):
def get_datastore_ref_and_name(session, cluster=None, host=None, datastore_regex=None):
def _get_allowed_datastores(data_stores, datastore_regex, allowed_types):
def get_available_datastores(session, cluster=None, datastore_regex=None):
def get_vmdk_backed_disk_uuid(hardware_devices, volume_uuid):
def get_vmdk_backed_disk_device(hardware_devices, uuid):
def get_vmdk_volume_disk(hardware_devices, path=None):
def get_res_pool_ref(session, cluster, node_mo_id):
def get_all_cluster_mors(session):
def get_all_res_pool_mors(session):
def get_dynamic_property_mor(session, mor_ref, attribute):
def find_entity_mor(entity_list, entity_name):
def get_all_cluster_refs_by_name(session, path_list):
def get_dict_mor(session, list_obj):
def get_mo_id_from_instance(instance):
def get_vmdk_adapter_type(adapter_type):
def clone_vmref_for_instance(session, instance, vm_ref, host_ref, ds_ref, vmfolder_ref):
def disassociate_vmref_from_instance(session, instance, vm_ref=None, suffix='-orig'):
def associate_vmref_for_instance(session, instance, vm_ref=None, suffix='-orig'):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\volumeops.py
class VMwareVolumeOps(object):
def __init__(self, session, cluster=None, vc_support=False):
def attach_disk_to_vm(self, vm_ref, instance, adapter_type, disk_type, vmdk_path=None, disk_size=None, linked_clone=False, device_name=None):
def _update_volume_details(self, vm_ref, instance, volume_uuid):
def _get_volume_uuid(self, vm_ref, volume_uuid):
def detach_disk_from_vm(self, vm_ref, instance, device, destroy_disk=False):
def discover_st(self, data):
def get_volume_connector(self, instance):
def _get_volume_ref(self, volume_ref_name):
def _get_vmdk_base_volume_device(self, volume_ref):
def _attach_volume_vmdk(self, connection_info, instance, mountpoint):
def _attach_volume_iscsi(self, connection_info, instance, mountpoint):
def attach_volume(self, connection_info, instance, mountpoint):
def _relocate_vmdk_volume(self, volume_ref, res_pool, datastore):
def _get_res_pool_of_vm(self, vm_ref):
def _consolidate_vmdk_volume(self, instance, vm_ref, device, volume_ref):
def _get_vmdk_backed_disk_device(self, vm_ref, connection_info_data):
def _detach_volume_vmdk(self, connection_info, instance, mountpoint):
def _detach_volume_iscsi(self, connection_info, instance, mountpoint):
def detach_volume(self, connection_info, instance, mountpoint):
def attach_root_volume(self, connection_info, instance, mountpoint, datastore):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\volume_util.py
class StorageError(Exception):
def __init__(self, message=None):
def get_host_iqn(session, cluster=None):
def find_st(session, data, cluster=None):
def rescan_iscsi_hba(session, cluster=None, target_portal=None):
def _add_iscsi_send_target_host(session, storage_system_mor, hba_device, target_portal):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\__init__.py
\OpenStack\nova-2014.1\nova\virt\volumeutils.py
def get_iscsi_initiator():
\OpenStack\nova-2014.1\nova\virt\watchdog_actions.py
def is_valid_watchdog_action(val):
\OpenStack\nova-2014.1\nova\virt\xenapi\agent.py
def _call_agent(session, instance, vm_ref, method, addl_args=None, timeout=None, success_codes=None):
def is_upgrade_required(current_version, available_version):
class XenAPIBasedAgent(object):
def __init__(self, session, virtapi, instance, vm_ref):
def _add_instance_fault(self, error, exc_info):
def _call_agent(self, method, addl_args=None, timeout=None, success_codes=None, ignore_errors=True):
def get_version(self):
def _get_expected_build(self):
def update_if_needed(self, version):
def _perform_update(self, agent_build):
def _exchange_key_with_agent(self):
def _save_instance_password_if_sshkey_present(self, new_pass):
def set_admin_password(self, new_pass):
def inject_ssh_key(self):
def inject_files(self, injected_files):
def inject_file(self, path, contents):
def resetnetwork(self):
def _skip_ssh_key_inject(self):
def _skip_inject_files_at_boot(self):
def _get_sys_meta_key(self, key):
def find_guest_agent(base_dir):
def should_use_agent(instance):
class SimpleDH(object):
def __init__(self):
def generate_private(self):
def get_public(self):
def compute_shared(self, other):
def _run_ssl(self, text, decrypt=False):
def encrypt(self, text):
def decrypt(self, text):
\OpenStack\nova-2014.1\nova\virt\xenapi\client\objects.py
class XenAPISessionObject(object):
def __init__(self, session, name):
def _call_method(self, method_name, *args):
def __getattr__(self, method_name):
class VM(XenAPISessionObject):
def __init__(self, session):
class VBD(XenAPISessionObject):
def __init__(self, session):
def plug(self, vbd_ref, vm_ref):
def synchronized_plug():
def unplug(self, vbd_ref, vm_ref):
def synchronized_unplug():
class VDI(XenAPISessionObject):
def __init__(self, session):
class SR(XenAPISessionObject):
def __init__(self, session):
class PBD(XenAPISessionObject):
def __init__(self, session):
class PIF(XenAPISessionObject):
def __init__(self, session):
class VLAN(XenAPISessionObject):
def __init__(self, session):
class Host(XenAPISessionObject):
def __init__(self, session):
class Network(XenAPISessionObject):
def __init__(self, session):
class Pool(XenAPISessionObject):
def __init__(self, session):
\OpenStack\nova-2014.1\nova\virt\xenapi\client\session.py
def apply_session_helpers(session):
class XenAPISession(object):
def __init__(self, url, user, pw):
def _verify_plugin_version(self):
def _create_first_session(self, url, user, pw, exception):
def _populate_session_pool(self, url, user, pw, exception):
def _get_host_uuid(self):
def _get_product_version_and_brand(self):
def _get_software_version(self):
def get_session_id(self):
def _get_session(self):
def _get_host_ref(self):
def call_xenapi(self, method, *args):
def call_plugin(self, plugin, fn, args):
def call_plugin_serialized(self, plugin, fn, *args, **kwargs):
def call_plugin_serialized_with_retry(self, plugin, fn, num_retries, callback, *args, **kwargs):
def _is_retryable_exception(self, exc):
def _create_session(self, url):
def _unwrap_plugin_exceptions(self, func, *args, **kwargs):
def get_rec(self, record_type, ref):
def get_all_refs_and_recs(self, record_type):
\OpenStack\nova-2014.1\nova\virt\xenapi\client\__init__.py
\OpenStack\nova-2014.1\nova\virt\xenapi\driver.py
class XenAPIDriver(driver.ComputeDriver):
def __init__(self, virtapi, read_only=False):
def host_state(self):
def init_host(self, host):
def instance_exists(self, instance_name):
def estimate_instance_overhead(self, instance_info):
def list_instances(self):
def list_instance_uuids(self):
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=None):
def confirm_migration(self, migration, instance, network_info):
def finish_revert_migration(self, context, instance, network_info, block_device_info=None, power_on=True):
def finish_migration(self, context, migration, instance, disk_info, network_info, image_meta, resize_instance=False, block_device_info=None, power_on=True):
def snapshot(self, context, instance, image_id, update_task_state):
def reboot(self, context, instance, network_info, reboot_type, block_device_info=None, bad_volumes_callback=None):
def set_admin_password(self, instance, new_pass):
def inject_file(self, instance, b64_path, b64_contents):
def change_instance_metadata(self, context, instance, diff):
def destroy(self, context, instance, network_info, block_device_info=None, destroy_disks=True):
def cleanup(self, context, instance, network_info, block_device_info=None, destroy_disks=True):
def pause(self, instance):
def unpause(self, instance):
def migrate_disk_and_power_off(self, context, instance, dest, flavor, network_info, block_device_info=None):
def suspend(self, instance):
def resume(self, context, instance, network_info, block_device_info=None):
def rescue(self, context, instance, network_info, image_meta, rescue_password):
def set_bootable(self, instance, is_bootable):
def unrescue(self, instance, network_info):
def power_off(self, instance):
def power_on(self, context, instance, network_info, block_device_info=None):
def soft_delete(self, instance):
def restore(self, instance):
def poll_rebooting_instances(self, timeout, instances):
def reset_network(self, instance):
def inject_network_info(self, instance, network_info):
def plug_vifs(self, instance_ref, network_info):
def unplug_vifs(self, instance_ref, network_info):
def get_info(self, instance):
def get_diagnostics(self, instance):
def get_all_bw_counters(self, instances):
def get_console_output(self, context, instance):
def get_vnc_console(self, context, instance):
def get_volume_connector(self, instance):
def get_host_ip_addr():
def attach_volume(self, context, connection_info, instance, mountpoint, disk_bus=None, device_type=None, encryption=None):
def detach_volume(self, connection_info, instance, mountpoint, encryption=None):
def get_console_pool_info(self, console_type):
def get_available_resource(self, nodename):
def ensure_filtering_rules_for_instance(self, instance_ref, network_info):
def check_can_live_migrate_destination(self, ctxt, instance_ref, src_compute_info, dst_compute_info, block_migration=False, disk_over_commit=False):
def check_can_live_migrate_destination_cleanup(self, ctxt, dest_check_data):
def check_can_live_migrate_source(self, ctxt, instance_ref, dest_check_data):
def get_instance_disk_info(self, instance_name):
def live_migration(self, ctxt, instance_ref, dest, post_method, recover_method, block_migration=False, migrate_data=None):
def rollback_live_migration_at_destination(self, context, instance, network_info, block_device_info):
def pre_live_migration(self, context, instance_ref, block_device_info, network_info, data, migrate_data=None):
def post_live_migration(self, ctxt, instance_ref, block_device_info, migrate_data=None):
def post_live_migration_at_destination(self, ctxt, instance_ref, network_info, block_migration, block_device_info=None):
def unfilter_instance(self, instance_ref, network_info):
def refresh_security_group_rules(self, security_group_id):
def refresh_security_group_members(self, security_group_id):
def refresh_instance_security_rules(self, instance):
def refresh_provider_fw_rules(self):
def get_host_stats(self, refresh=False):
def host_power_action(self, host, action):
def set_host_enabled(self, host, enabled):
def get_host_uptime(self, host):
def host_maintenance_mode(self, host, mode):
def add_to_aggregate(self, context, aggregate, host, **kwargs):
def remove_from_aggregate(self, context, aggregate, host, **kwargs):
def undo_aggregate_operation(self, context, op, aggregate, host, set_error=True):
def resume_state_on_host_boot(self, context, instance, network_info, block_device_info=None):
def get_per_instance_usage(self):
\OpenStack\nova-2014.1\nova\virt\xenapi\fake.py
def log_db_contents(msg=None):
def reset():
def reset_table(table):
def _create_pool(name_label):
def create_host(name_label, hostname='fake_name', address='fake_addr'):
def create_network(name_label, bridge):
def create_vm(name_label, status, **kwargs):
def destroy_vm(vm_ref):
def destroy_vbd(vbd_ref):
def destroy_vdi(vdi_ref):
def create_vdi(name_label, sr_ref, **kwargs):
def after_VDI_create(vdi_ref, vdi_rec):
def create_vbd(vm_ref, vdi_ref, userdevice=0):
def after_VBD_create(vbd_ref, vbd_rec):
def after_VM_create(vm_ref, vm_rec):
def create_pbd(host_ref, sr_ref, attached):
def create_task(name_label):
def _create_local_srs(host_ref):
def create_sr(**kwargs):
def _create_local_pif(host_ref):
def _create_object(table, obj):
def _create_sr(table, obj):
def _create_vlan(pif_ref, vlan_num, network_ref):
def get_all(table):
def get_all_records(table):
def _query_matches(record, query):
def get_all_records_where(table_name, query):
def get_record(table, ref):
def check_for_session_leaks():
def as_value(s):
def as_json(*args, **kwargs):
class Failure(Exception):
def __init__(self, details):
def __str__(self):
def _details_map(self):
class SessionBase(object):
def __init__(self, uri):
def pool_get_default_SR(self, _1, pool_ref):
def VBD_insert(self, _1, vbd_ref, vdi_ref):
def VBD_plug(self, _1, ref):
def VBD_unplug(self, _1, ref):
def VBD_add_to_other_config(self, _1, vbd_ref, key, value):
def VBD_get_other_config(self, _1, vbd_ref):
def PBD_create(self, _1, pbd_rec):
def PBD_plug(self, _1, pbd_ref):
def PBD_unplug(self, _1, pbd_ref):
def SR_introduce(self, _1, sr_uuid, label, desc, type, content_type, shared, sm_config):
def SR_forget(self, _1, sr_ref):
def SR_scan(self, _1, sr_ref):
def VM_get_xenstore_data(self, _1, vm_ref):
def VM_remove_from_xenstore_data(self, _1, vm_ref, key):
def VM_add_to_xenstore_data(self, _1, vm_ref, key, value):
def VM_pool_migrate(self, _1, vm_ref, host_ref, options):
def VDI_remove_from_other_config(self, _1, vdi_ref, key):
def VDI_add_to_other_config(self, _1, vdi_ref, key, value):
def VDI_copy(self, _1, vdi_to_copy_ref, sr_ref):
def VDI_clone(self, _1, vdi_to_clone_ref):
def host_compute_free_memory(self, _1, ref):
def _plugin_agent_version(self, method, args):
def _plugin_agent_key_init(self, method, args):
def _plugin_agent_password(self, method, args):
def _plugin_agent_inject_file(self, method, args):
def _plugin_agent_resetnetwork(self, method, args):
def _plugin_agent_agentupdate(self, method, args):
def _plugin_noop(self, method, args):
def _plugin_pickle_noop(self, method, args):
def _plugin_migration_transfer_vhd(self, method, args):
def _plugin_xenhost_host_data(self, method, args):
def _plugin_poweraction(self, method, args):
def _plugin_xenhost_set_host_enabled(self, method, args):
def _plugin_xenhost_host_uptime(self, method, args):
def _plugin_xenhost_get_pci_device_details(self, method, args):
def _plugin_xenhost_get_pci_type(self, method, args):
def _plugin_console_get_console_log(self, method, args):
def _plugin_nova_plugin_version_get_version(self, method, args):
def _plugin_xenhost_query_gc(self, method, args):
def host_call_plugin(self, _1, _2, plugin, method, args):
def VDI_get_virtual_size(self, *args):
def VDI_resize_online(self, *args):
def _VM_reboot(self, session, vm_ref):
def VM_clean_reboot(self, session, vm_ref):
def VM_hard_reboot(self, session, vm_ref):
def VM_hard_shutdown(self, session, vm_ref):
def VM_suspend(self, session, vm_ref):
def VM_pause(self, session, vm_ref):
def pool_eject(self, session, host_ref):
def pool_join(self, session, hostname, username, password):
def pool_set_name_label(self, session, pool_ref, name):
def host_migrate_receive(self, session, destref, nwref, options):
def VM_assert_can_migrate(self, session, vmref, migrate_data, live, vdi_map, vif_map, options):
def VM_migrate_send(self, session, mref, migrate_data, live, vdi_map, vif_map, options):
def VM_remove_from_blocked_operations(self, session, vm_ref, key):
def xenapi_request(self, methodname, params):
def _login(self, method, params):
def _logout(self):
def __getattr__(self, name):
def _is_gettersetter(self, name, getter):
def _is_create(self, name):
def _is_destroy(self, name):
def _is_method(self, name, meth):
def _getter(self, name, params):
def _setter(self, name, params):
def _create(self, name, params):
def _destroy(self, name, params):
def _async(self, name, params):
def _check_session(self, params):
def _check_arg_count(self, params, expected):
def _get_by_field(self, recs, k, v, return_singleton):
class FakeXenAPI(object):
def __init__(self):
class _Dispatcher:
def __init__(self, send, name):
def __repr__(self):
def __getattr__(self, name):
def __call__(self, *args):
\OpenStack\nova-2014.1\nova\virt\xenapi\firewall.py
class Dom0IptablesFirewallDriver(firewall.IptablesFirewallDriver):
def _plugin_execute(self, *cmd, **kwargs):
def __init__(self, virtapi, xenapi_session=None, **kwargs):
def _build_tcp_udp_rule(self, rule, version):
def _provider_rules(self):
\OpenStack\nova-2014.1\nova\virt\xenapi\host.py
class Host(object):
def __init__(self, session, virtapi):
def host_power_action(self, _host, action):
def host_maintenance_mode(self, host, mode):
def set_host_enabled(self, host, enabled):
def get_host_uptime(self, _host):
class HostState(object):
def __init__(self, session):
def _get_passthrough_devices(self):
def _compile_hex(pattern):
def _parse_pci_device_string(dev_string):
def get_host_stats(self, refresh=False):
def update_status(self):
def to_supported_instances(host_capabilities):
def call_xenhost(session, method, arg_dict):
def _uuid_find(context, host, name_label):
def _host_find(context, session, src_aggregate, host_ref):
\OpenStack\nova-2014.1\nova\virt\xenapi\image\bittorrent.py
class BittorrentStore(object):
def _lookup_torrent_url_fn():
def download_image(self, context, session, instance, image_id):
def upload_image(self, context, session, instance, vdi_uuids, image_id):
\OpenStack\nova-2014.1\nova\virt\xenapi\image\glance.py
class GlanceStore(object):
def _call_glance_plugin(self, session, fn, params):
def pick_glance(kwargs):
def _make_params(self, context, session, image_id):
def download_image(self, context, session, instance, image_id):
def upload_image(self, context, session, instance, vdi_uuids, image_id):
\OpenStack\nova-2014.1\nova\virt\xenapi\image\utils.py
class GlanceImage(object):
def __init__(self, context, image_href_or_id):
def meta(self):
def download_to(self, fileobj):
def is_raw_tgz(self):
def data(self):
class RawImage(object):
def __init__(self, glance_image):
def get_size(self):
def stream_to(self, fileobj):
class IterableToFileAdapter(object):
def __init__(self, iterable):
def read(self, size):
class RawTGZImage(object):
def __init__(self, glance_image):
def _as_file(self):
def _as_tarfile(self):
def get_size(self):
def stream_to(self, target_file):
\OpenStack\nova-2014.1\nova\virt\xenapi\image\vdi_through_dev.py
class VdiThroughDevStore(object):
def upload_image(self, context, session, instance, vdi_uuids, image_id):
def download_image(self, context, session, instance, image_id):
class UploadToGlanceAsRawTgz(object):
def __init__(self, context, session, instance, vdi_uuids, image_id):
def _get_virtual_size(self):
def _get_vdi_ref(self):
def _perform_upload(self, devpath):
def _create_pipe(self):
def upload_image(self):
class TarGzProducer(object):
def __init__(self, devpath, writefile, size, fname):
def get_metadata(self):
def start(self):
def _open_file(self, *args):
\OpenStack\nova-2014.1\nova\virt\xenapi\image\__init__.py
\OpenStack\nova-2014.1\nova\virt\xenapi\network_utils.py
def find_network_with_name_label(session, name_label):
def find_network_with_bridge(session, bridge):
\OpenStack\nova-2014.1\nova\virt\xenapi\pool.py
class ResourcePool(object):
def __init__(self, session, virtapi):
def undo_aggregate_operation(self, context, op, aggregate, host, set_error):
def add_to_aggregate(self, context, aggregate, host, slave_info=None):
def remove_from_aggregate(self, context, aggregate, host, slave_info=None):
def _join_slave(self, aggregate_id, host, compute_uuid, url, user, passwd):
def _eject_slave(self, aggregate_id, compute_uuid, host_uuid):
def _init_pool(self, aggregate_id, aggregate_name):
def _clear_pool(self, aggregate_id):
def _create_slave_info(self):
def swap_xapi_host(url, host_addr):
\OpenStack\nova-2014.1\nova\virt\xenapi\pool_states.py
def is_hv_pool(metadata):
\OpenStack\nova-2014.1\nova\virt\xenapi\vif.py
class XenVIFDriver(object):
def __init__(self, xenapi_session):
class XenAPIBridgeDriver(XenVIFDriver):
def plug(self, instance, vif, vm_ref=None, device=None):
def _ensure_vlan_bridge(self, network):
def unplug(self, instance, vif):
class XenAPIOpenVswitchDriver(XenVIFDriver):
def plug(self, instance, vif, vm_ref=None, device=None):
def unplug(self, instance, vif):
\OpenStack\nova-2014.1\nova\virt\xenapi\vmops.py
def make_step_decorator(context, instance, update_instance_progress, total_offset=0):
def bump_progress():
def step_decorator(f):
class VMOps(object):
def __init__(self, session, virtapi):
def agent_enabled(self, instance):
def _get_agent(self, instance, vm_ref):
def instance_exists(self, name_label):
def list_instances(self):
def list_instance_uuids(self):
def confirm_migration(self, migration, instance, network_info):
def _destroy_orig_vm(self, instance, network_info):
def _attach_mapped_block_devices(self, instance, block_device_info):
def finish_revert_migration(self, context, instance, block_device_info=None, power_on=True):
def _restore_orig_vm_and_cleanup_orphan(self, instance, block_device_info=None, power_on=True):
def finish_migration(self, context, migration, instance, disk_info, network_info, image_meta, resize_instance, block_device_info=None, power_on=True):
def null_step_decorator(f):
def create_disks_step(undo_mgr, disk_image_type, image_meta, name_label):
def completed_callback():
def _start(self, instance, vm_ref=None, bad_volumes_callback=None):
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=None, name_label=None, rescue=False):
def create_disks_step(undo_mgr, disk_image_type, image_meta, name_label):
def _spawn(self, context, instance, image_meta, step, create_disks_step, first_boot, injected_files=None, admin_password=None, network_info=None, block_device_info=None, name_label=None, rescue=False, power_on=True, resize=True, completed_callback=None):
def attach_disks(undo_mgr, vm_ref, vdis, disk_image_type):
def attach_pci_devices(undo_mgr, vm_ref):
def determine_disk_image_type_step(undo_mgr):
def create_kernel_ramdisk_step(undo_mgr):
def create_vm_record_step(undo_mgr, disk_image_type, kernel_file, ramdisk_file):
def attach_devices_step(undo_mgr, vm_ref, vdis, disk_image_type):
def inject_instance_data_step(undo_mgr, vm_ref, vdis):
def setup_network_step(undo_mgr, vm_ref):
def boot_instance_step(undo_mgr, vm_ref):
def configure_booted_instance_step(undo_mgr, vm_ref):
def apply_security_group_filters_step(undo_mgr):
def _attach_orig_disk_for_rescue(self, instance, vm_ref):
def _file_inject_vm_settings(self, instance, vm_ref, vdis, network_info):
def _ensure_instance_name_unique(self, name_label):
def _ensure_enough_free_mem(self, instance):
def _create_vm_record(self, context, instance, name_label, disk_image_type, kernel_file, ramdisk_file, image_meta):
def _attach_disks(self, instance, vm_ref, name_label, vdis, disk_image_type, network_info, admin_password=None, files=None):
def _wait_for_instance_to_start(self, instance, vm_ref):
def _configure_new_instance_with_agent(self, instance, vm_ref, injected_files, admin_password):
def _prepare_instance_filter(self, instance, network_info):
def _get_vm_opaque_ref(self, instance, check_rescue=False):
def _acquire_bootlock(self, vm):
def _release_bootlock(self, vm):
def snapshot(self, context, instance, image_id, update_task_state):
def _get_orig_vm_name_label(self, instance):
def _update_instance_progress(self, context, instance, step, total_steps):
def _resize_ensure_vm_is_shutdown(self, instance, vm_ref):
def _migrate_disk_resizing_down(self, context, instance, dest, flavor, vm_ref, sr_path):
def fake_step_to_match_resizing_up():
def rename_and_power_off_vm(undo_mgr):
def create_copy_vdi_and_resize(undo_mgr, old_vdi_ref):
def transfer_vhd_to_dest(new_vdi_ref, new_vdi_uuid):
def _migrate_disk_resizing_up(self, context, instance, dest, vm_ref, sr_path):
def fake_step_to_show_snapshot_complete():
def transfer_immutable_vhds(root_vdi_uuids):
def _process_ephemeral_chain_recursive(ephemeral_chains, active_vdi_uuids):
def transfer_ephemeral_disks_then_all_leaf_vdis():
def power_down_and_transfer_leaf_vhds(root_vdi_uuid, ephemeral_vdi_uuids=None):
def _apply_orig_vm_name_label(self, instance, vm_ref):
def _ensure_not_resize_down_ephemeral(self, instance, flavor):
def migrate_disk_and_power_off(self, context, instance, dest, flavor, block_device_info):
def _detach_block_devices_from_orig_vm(self, instance, block_device_info):
def _resize_up_vdis(self, instance, vdis):
def reboot(self, instance, reboot_type, bad_volumes_callback=None):
def set_admin_password(self, instance, new_pass):
def inject_file(self, instance, path, contents):
def _sanitize_xenstore_key(key):
def _inject_instance_metadata(self, instance, vm_ref):
def store_meta(topdir, data_dict):
def _inject_auto_disk_config(self, instance, vm_ref):
def store_auto_disk_config(key, value):
def change_instance_metadata(self, instance, diff):
def process_change(location, change):
def update_meta():
def _find_root_vdi_ref(self, vm_ref):
def _destroy_vdis(self, instance, vm_ref):
def _destroy_kernel_ramdisk(self, instance, vm_ref):
def _destroy_rescue_instance(self, rescue_vm_ref, original_vm_ref):
def destroy(self, instance, network_info, block_device_info=None, destroy_disks=True):
def _destroy(self, instance, vm_ref, network_info=None, destroy_disks=True):
def pause(self, instance):
def unpause(self, instance):
def suspend(self, instance):
def resume(self, instance):
def rescue(self, context, instance, network_info, image_meta, rescue_password):
def set_bootable(self, instance, is_bootable):
def unrescue(self, instance):
def soft_delete(self, instance):
def restore(self, instance):
def power_off(self, instance):
def power_on(self, instance):
def _cancel_stale_tasks(self, timeout, task):
def poll_rebooting_instances(self, timeout, instances):
def get_info(self, instance, vm_ref=None):
def get_diagnostics(self, instance):
def _get_vif_device_map(self, vm_rec):
def get_all_bw_counters(self):
def get_console_output(self, instance):
def get_vnc_console(self, instance):
def _vif_xenstore_data(self, vif):
def get_ip(ip):
def fixed_ip_dict(ip, subnet):
def convert_route(route):
def inject_network_info(self, instance, network_info, vm_ref=None):
def update_nwinfo():
def _create_vifs(self, instance, vm_ref, network_info):
def plug_vifs(self, instance, network_info):
def unplug_vifs(self, instance, network_info):
def reset_network(self, instance, rescue=False):
def _inject_hostname(self, instance, vm_ref, rescue):
def update_hostname():
def _remove_hostname(self, instance, vm_ref):
def update_hostname():
def _write_to_xenstore(self, instance, path, value, vm_ref=None):
def _delete_from_xenstore(self, instance, path, vm_ref=None):
def _make_plugin_call(self, plugin, method, instance=None, vm_ref=None, **addl_args):
def _get_dom_id(self, instance=None, vm_ref=None, check_rescue=False):
def _add_to_param_xenstore(self, vm_ref, key, val):
def _remove_from_param_xenstore(self, vm_ref, key):
def refresh_security_group_rules(self, security_group_id):
def refresh_security_group_members(self, security_group_id):
def refresh_instance_security_rules(self, instance):
def refresh_provider_fw_rules(self):
def unfilter_instance(self, instance_ref, network_info):
def _get_host_uuid_from_aggregate(self, context, hostname):
def _ensure_host_in_aggregate(self, context, hostname):
def _get_host_opaque_ref(self, context, hostname):
def _migrate_receive(self, ctxt):
def _get_iscsi_srs(self, ctxt, instance_ref):
def check_can_live_migrate_destination(self, ctxt, instance_ref, block_migration=False, disk_over_commit=False):
def _is_xsm_sr_check_relaxed(self):
def check_can_live_migrate_source(self, ctxt, instance_ref, dest_check_data):
def _generate_vdi_map(self, destination_sr_ref, vm_ref, sr_ref=None):
def _call_live_migrate_command(self, command_name, vm_ref, migrate_data):
def live_migrate(self, context, instance, destination_hostname, post_method, recover_method, block_migration, migrate_data=None):
def post_live_migration(self, context, instance, migrate_data=None):
def post_live_migration_at_destination(self, context, instance, network_info, block_migration, block_device_info):
def get_per_instance_usage(self):
def _is_active(vm_rec):
def _get_uuid(vm_rec):
def attach_block_device_volumes(self, block_device_info):
\OpenStack\nova-2014.1\nova\virt\xenapi\vm_utils.py
class ImageType(object):
def to_string(cls, image_type):
def get_role(cls, image_type_id):
def get_vm_device_id(session, image_properties):
def _hypervisor_supports_device_id(version):
def create_vm(session, instance, name_label, kernel, ramdisk, use_pv_kernel=False, device_id=None):
def destroy_vm(session, instance, vm_ref):
OpenStack IndexPreviousNext
|
