OpenStack Study: nova
OpenStack IndexPreviousNext
class UnsupportedConfigDriveFormatException(HyperVException):
def __init__(self, message=None):
class VMUtils(object):
def __init__(self, host='.'):
def _init_hyperv_wmi_conn(self, host):
def list_instances(self):
def get_vm_summary_info(self, vm_name):
def _lookup_vm_check(self, vm_name):
def _lookup_vm(self, vm_name):
def vm_exists(self, vm_name):
def get_vm_id(self, vm_name):
def _get_vm_setting_data(self, vm):
def _set_vm_memory(self, vm, vmsetting, memory_mb, dynamic_memory_ratio):
def _set_vm_vcpus(self, vm, vmsetting, vcpus_num, limit_cpu_features):
def update_vm(self, vm_name, memory_mb, vcpus_num, limit_cpu_features, dynamic_memory_ratio):
def check_admin_permissions(self):
def create_vm(self, vm_name, memory_mb, vcpus_num, limit_cpu_features, dynamic_memory_ratio):
def _create_vm_obj(self, vs_man_svc, vm_name):
def get_vm_scsi_controller(self, vm_name):
def _get_vm_ide_controller(self, vm, ctrller_addr):
def get_vm_ide_controller(self, vm_name, ctrller_addr):
def get_attached_disks_count(self, scsi_controller_path):
def _get_new_setting_data(self, class_name):
def _get_new_resource_setting_data(self, resource_sub_type, class_name=None):
def attach_ide_drive(self, vm_name, path, ctrller_addr, drive_addr, drive_type=constants.IDE_DISK):
def create_scsi_controller(self, vm_name):
def attach_volume_to_controller(self, vm_name, controller_path, address, mounted_disk_path):
def set_nic_connection(self, vm_name, nic_name, vswitch_conn_data):
def _get_nic_data_by_name(self, name):
def create_nic(self, vm_name, nic_name, mac_address):
def set_vm_state(self, vm_name, req_state):
def _get_disk_resource_disk_path(self, disk_resource):
def get_vm_storage_paths(self, vm_name):
def _get_vm_disks(self, vm):
def destroy_vm(self, vm_name):
def check_ret_val(self, ret_val, job_path, success_values=[0]):
def _wait_for_job(self, job_path):
def _get_wmi_obj(self, path):
def _add_virt_resource(self, res_setting_data, vm_path):
def _modify_virt_resource(self, res_setting_data, vm_path):
def _remove_virt_resource(self, res_setting_data, vm_path):
def take_vm_snapshot(self, vm_name):
def remove_vm_snapshot(self, snapshot_path):
def detach_vm_disk(self, vm_name, disk_path):
def _get_mounted_disk_resource_from_path(self, disk_path):
def get_mounted_disk_by_drive_number(self, device_number):
def get_controller_volume_paths(self, controller_path):
def enable_vm_metrics_collection(self, vm_name):
\OpenStack\nova-2014.1\nova\virt\hyperv\vmutilsv2.py
class VMUtilsV2(vmutils.VMUtils):
def __init__(self, host='.'):
def _init_hyperv_wmi_conn(self, host):
def _create_vm_obj(self, vs_man_svc, vm_name):
def _get_vm_setting_data(self, vm):
def attach_ide_drive(self, vm_name, path, ctrller_addr, drive_addr, drive_type=constants.IDE_DISK):
def attach_volume_to_controller(self, vm_name, controller_path, address, mounted_disk_path):
def create_scsi_controller(self, vm_name):
def _get_disk_resource_disk_path(self, disk_resource):
def destroy_vm(self, vm_name):
def _add_virt_resource(self, res_setting_data, vm_path):
def _modify_virt_resource(self, res_setting_data, vm_path):
def _remove_virt_resource(self, res_setting_data, vm_path):
def get_vm_state(self, vm_name):
def take_vm_snapshot(self, vm_name):
def remove_vm_snapshot(self, snapshot_path):
def set_nic_connection(self, vm_name, nic_name, vswitch_conn_data):
def enable_vm_metrics_collection(self, vm_name):
def _enable_metrics(self, metric_svc, element, definition_path=None):
\OpenStack\nova-2014.1\nova\virt\hyperv\volumeops.py
class VolumeOps(object):
def __init__(self):
def ebs_root_in_block_devices(self, block_device_info):
def attach_volumes(self, block_device_info, instance_name, ebs_root):
def login_storage_targets(self, block_device_info):
def _login_storage_target(self, connection_info):
def attach_volume(self, connection_info, instance_name, ebs_root=False):
def _get_free_controller_slot(self, scsi_controller_path):
def detach_volumes(self, block_device_info, instance_name):
def logout_storage_target(self, target_iqn):
def detach_volume(self, connection_info, instance_name):
def get_volume_connector(self, instance):
def _get_mounted_disk_from_lun(self, target_iqn, target_lun, wait_for_device=False):
def disconnect_volume(self, physical_drive_path):
def get_target_from_disk_path(self, physical_drive_path):
\OpenStack\nova-2014.1\nova\virt\hyperv\volumeutils.py
class VolumeUtils(basevolumeutils.BaseVolumeUtils):
def __init__(self):
def execute(self, *args, **kwargs):
def login_storage_target(self, target_lun, target_iqn, target_portal):
def logout_storage_target(self, target_iqn):
def execute_log_out(self, session_id):
\OpenStack\nova-2014.1\nova\virt\hyperv\volumeutilsv2.py
class VolumeUtilsV2(basevolumeutils.BaseVolumeUtils):
def __init__(self, host='.'):
def login_storage_target(self, target_lun, target_iqn, target_portal):
def logout_storage_target(self, target_iqn):
def execute_log_out(self, session_id):
\OpenStack\nova-2014.1\nova\virt\hyperv\__init__.py
\OpenStack\nova-2014.1\nova\virt\imagecache.py
class ImageCacheManager(object):
def __init__(self):
def _get_base(self):
def _list_running_instances(self, context, all_instances):
def _list_base_images(self, base_dir):
def _age_and_verify_cached_images(self, context, all_instances, base_dir):
def update(self, context, all_instances):
\OpenStack\nova-2014.1\nova\virt\imagehandler\__init__.py
def _image_handler_asso(handler, path, location, image_meta):
def _image_handler_disasso(handler, path):
def _match_locations(locations, schemes):
def load_image_handlers(driver):
def handle_image(context=None, image_id=None, user_id=None, project_id=None, target_path=None):
\OpenStack\nova-2014.1\nova\virt\images.py
def qemu_img_info(path):
def convert_image(source, dest, out_format, run_as_root=False):
def fetch(context, image_href, path, _user_id, _project_id, max_size=0):
def fetch_to_raw(context, image_href, path, user_id, project_id, max_size=0):
\OpenStack\nova-2014.1\nova\virt\libvirt\blockinfo.py
def has_disk_dev(mapping, disk_dev):
def get_dev_prefix_for_disk_bus(disk_bus):
def get_dev_count_for_disk_bus(disk_bus):
def find_disk_dev_for_disk_bus(mapping, bus, last_device=False):
def is_disk_bus_valid_for_virt(virt_type, disk_bus):
def get_disk_bus_for_device_type(virt_type, image_meta=None, device_type="disk"):
def get_disk_bus_for_disk_dev(virt_type, disk_dev):
def get_next_disk_info(mapping, disk_bus, device_type='disk', last_device=False, boot_index=None):
def get_eph_disk(index):
def get_config_drive_type():
def get_info_from_bdm(virt_type, bdm, mapping={}, disk_bus=None, dev_type=None, allowed_types=None, assigned_devices=None):
def get_device_name(bdm):
def get_root_info(virt_type, image_meta, root_bdm, disk_bus, cdrom_bus, root_device_name=None):
def default_device_names(virt_type, context, instance, root_device_name, ephemerals, swap, block_device_mapping):
def has_default_ephemeral(instance, disk_bus, block_device_info, mapping):
def update_bdm(bdm, info):
def get_disk_mapping(virt_type, instance, disk_bus, cdrom_bus, block_device_info=None, image_meta=None, rescue=False):
def get_disk_info(virt_type, instance, block_device_info=None, image_meta=None, rescue=False):
def get_boot_order(disk_info):
\OpenStack\nova-2014.1\nova\virt\libvirt\config.py
class LibvirtConfigObject(object):
def __init__(self, **kwargs):
def _text_node(name, value):
def format_dom(self):
def parse_str(self, xmlstr):
def parse_dom(self, xmldoc):
def to_xml(self, pretty_print=True):
class LibvirtConfigCaps(LibvirtConfigObject):
def __init__(self, **kwargs):
def parse_dom(self, xmldoc):
def format_dom(self):
class LibvirtConfigCapsHost(LibvirtConfigObject):
def __init__(self, **kwargs):
def parse_dom(self, xmldoc):
def format_dom(self):
class LibvirtConfigCapsGuest(LibvirtConfigObject):
def __init__(self, **kwargs):
def parse_dom(self, xmldoc):
def format_dom(self):
class LibvirtConfigGuestTimer(LibvirtConfigObject):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestClock(LibvirtConfigObject):
def __init__(self, **kwargs):
def format_dom(self):
def add_timer(self, tm):
class LibvirtConfigCPUFeature(LibvirtConfigObject):
def __init__(self, name=None, **kwargs):
def parse_dom(self, xmldoc):
def format_dom(self):
class LibvirtConfigCPU(LibvirtConfigObject):
def __init__(self, **kwargs):
def parse_dom(self, xmldoc):
def format_dom(self):
def add_feature(self, feat):
class LibvirtConfigGuestCPUFeature(LibvirtConfigCPUFeature):
def __init__(self, name=None, **kwargs):
def format_dom(self):
class LibvirtConfigGuestCPU(LibvirtConfigCPU):
def __init__(self, **kwargs):
def parse_dom(self, xmldoc):
def format_dom(self):
class LibvirtConfigGuestSMBIOS(LibvirtConfigObject):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestSysinfo(LibvirtConfigObject):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestDevice(LibvirtConfigObject):
def __init__(self, **kwargs):
class LibvirtConfigGuestDisk(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
def parse_dom(self, xmldoc):
class LibvirtConfigGuestSnapshotDisk(LibvirtConfigObject):
def __init__(self, **kwargs):
def format_dom(self):
def parse_dom(self, xmldoc):
class LibvirtConfigGuestFilesys(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestInterface(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
def add_filter_param(self, key, value):
def add_vport_param(self, key, value):
class LibvirtConfigGuestInput(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestGraphics(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigSeclabel(LibvirtConfigObject):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestVideo(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestController(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestHostdev(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
def parse_dom(self, xmldoc):
class LibvirtConfigGuestHostdevPCI(LibvirtConfigGuestHostdev):
def __init__(self, **kwargs):
def format_dom(self):
def parse_dom(self, xmldoc):
class LibvirtConfigGuestCharBase(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestChar(LibvirtConfigGuestCharBase):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestSerial(LibvirtConfigGuestChar):
def __init__(self, **kwargs):
class LibvirtConfigGuestConsole(LibvirtConfigGuestChar):
def __init__(self, **kwargs):
class LibvirtConfigGuestChannel(LibvirtConfigGuestCharBase):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuestWatchdog(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
class LibvirtConfigGuest(LibvirtConfigObject):
def __init__(self, **kwargs):
def _format_basic_props(self, root):
def _format_os(self, root):
def _format_features(self, root):
def _format_cputune(self, root):
def _format_devices(self, root):
def format_dom(self):
def parse_dom(self, xmldoc):
def add_device(self, dev):
def set_clock(self, clk):
class LibvirtConfigGuestSnapshot(LibvirtConfigObject):
def __init__(self, **kwargs):
def format_dom(self):
def add_disk(self, disk):
class LibvirtConfigNodeDevice(LibvirtConfigObject):
def __init__(self, **kwargs):
def parse_dom(self, xmldoc):
class LibvirtConfigNodeDevicePciCap(LibvirtConfigObject):
def __init__(self, **kwargs):
def parse_dom(self, xmldoc):
class LibvirtConfigNodeDevicePciSubFunctionCap(LibvirtConfigObject):
def __init__(self, **kwargs):
def parse_dom(self, xmldoc):
class LibvirtConfigGuestRng(LibvirtConfigGuestDevice):
def __init__(self, **kwargs):
def format_dom(self):
\OpenStack\nova-2014.1\nova\virt\libvirt\designer.py
def set_vif_guest_frontend_config(conf, mac, model, driver):
def set_vif_host_backend_bridge_config(conf, brname, tapname=None):
def set_vif_host_backend_ethernet_config(conf, tapname):
def set_vif_host_backend_ovs_config(conf, brname, interfaceid, tapname=None):
def set_vif_host_backend_802qbg_config(conf, devname, managerid, typeid, typeidversion, instanceid, tapname=None):
def set_vif_host_backend_802qbh_config(conf, devname, profileid, tapname=None):
def set_vif_host_backend_direct_config(conf, devname):
def set_vif_bandwidth_config(conf, inst_type):
\OpenStack\nova-2014.1\nova\virt\libvirt\dmcrypt.py
def volume_name(base):
def create_volume(target, device, cipher, key_size, key):
def delete_volume(target):
def list_volumes():
\OpenStack\nova-2014.1\nova\virt\libvirt\driver.py
def patch_tpool_proxy():
def str_method(self):
def repr_method(self):
def libvirt_error_handler(context, err):
class LibvirtDriver(driver.ComputeDriver):
def __init__(self, virtapi, read_only=False):
def disk_cachemode(self):
def host_state(self):
def set_cache_mode(self, conf):
def _has_min_version(conn, lv_ver=None, hv_ver=None, hv_type=None):
def has_min_version(self, lv_ver=None, hv_ver=None, hv_type=None):
def _native_thread(self):
def _dispatch_thread(self):
def _event_lifecycle_callback(conn, dom, event, detail, opaque):
def _queue_event(self, event):
def _dispatch_events(self):
def _init_events_pipe(self):
def _init_events(self):
def _do_quality_warnings(self):
def init_host(self, host):
def _get_new_connection(self):
def _get_connection(self):
def _close_callback(self, conn, reason, opaque):
def _test_connection(conn):
def uri():
def _connect(uri, read_only):
def _connect_auth_cb(creds, opaque):
def get_num_instances(self):
def instance_exists(self, instance_name):
def list_instance_ids(self):
def list_instances(self):
def list_instance_uuids(self):
def plug_vifs(self, instance, network_info):
def unplug_vifs(self, instance, network_info):
def _teardown_container(self, instance):
def _destroy(self, instance):
def _wait_for_destroy(expected_domid):
def destroy(self, context, instance, network_info, block_device_info=None, destroy_disks=True):
def _undefine_domain(self, instance):
def cleanup(self, context, instance, network_info, block_device_info=None, destroy_disks=True):
def _cleanup_rbd(self, instance):
def belongs_to_instance(disk):
def _cleanup_lvm(self, instance):
def _lvm_disks(self, instance):
def get_volume_connector(self, instance):
def _cleanup_resize(self, instance, network_info):
def volume_driver_method(self, method_name, connection_info, *args, **kwargs):
def _get_volume_encryptor(self, connection_info, encryption):
def attach_volume(self, context, connection_info, instance, mountpoint, disk_bus=None, device_type=None, encryption=None):
def _swap_volume(self, domain, disk_path, new_path):
def swap_volume(self, old_connection_info, new_connection_info, instance, mountpoint):
def _get_disk_xml(xml, device):
def _get_existing_domain_xml(self, instance, network_info, block_device_info=None):
def detach_volume(self, connection_info, instance, mountpoint, encryption=None):
def attach_interface(self, instance, image_meta, vif):
def detach_interface(self, instance, vif):
def _create_snapshot_metadata(self, base, instance, img_fmt, snp_name):
def snapshot(self, context, instance, image_href, update_task_state):
def _wait_for_block_job(domain, disk_path, abort_on_error=False):
def _live_snapshot(self, domain, disk_path, out_path, image_format):
def _volume_snapshot_update_status(self, context, snapshot_id, status):
def _volume_snapshot_create(self, context, instance, domain, volume_id, snapshot_id, new_file):
def volume_snapshot_create(self, context, instance, volume_id, create_info):
def _volume_snapshot_delete(self, context, instance, volume_id, snapshot_id, delete_info=None):
def volume_snapshot_delete(self, context, instance, volume_id, snapshot_id, delete_info=None):
def reboot(self, context, instance, network_info, reboot_type='SOFT', block_device_info=None, bad_volumes_callback=None):
def _soft_reboot(self, instance):
def _hard_reboot(self, context, instance, network_info, block_device_info=None):
def _wait_for_reboot():
def pause(self, instance):
def unpause(self, instance):
def power_off(self, instance):
def power_on(self, context, instance, network_info, block_device_info=None):
def suspend(self, instance):
def resume(self, context, instance, network_info, block_device_info=None):
def resume_state_on_host_boot(self, context, instance, network_info, block_device_info=None):
def rescue(self, context, instance, network_info, image_meta, rescue_password):
def unrescue(self, instance, network_info):
def poll_rebooting_instances(self, timeout, instances):
def _enable_hairpin(self, xml):
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=None):
def _wait_for_boot():
def _flush_libvirt_console(self, pty):
def _append_to_file(self, data, fpath):
def get_console_output(self, context, instance):
def get_host_ip_addr():
def get_vnc_console(self, context, instance):
def get_vnc_port_for_instance(instance_name):
def get_spice_console(self, context, instance):
def get_spice_ports_for_instance(instance_name):
def _supports_direct_io(dirpath):
def _create_local(target, local_size, unit='G', fs_format=None, label=None):
def _create_ephemeral(self, target, ephemeral_size, fs_label, os_type, is_block_dev=False, max_size=None):
def _create_swap(target, swap_mb, max_size=None):
def _get_console_log_path(instance):
def _get_disk_config_path(instance):
def _chown_console_log_for_instance(self, instance):
def _chown_disk_config_for_instance(self, instance):
def _is_booted_from_volume(instance, disk_mapping):
def _inject_data(self, instance, network_info, admin_pass, files, suffix):
def _create_image(self, context, instance, disk_mapping, suffix='', disk_images=None, network_info=None, block_device_info=None, files=None, admin_pass=None, inject_files=True):
def image(fname, image_type=CONF.libvirt.images_type):
def raw(fname):
def _prepare_pci_devices_for_use(self, pci_devices):
def _detach_pci_devices(self, dom, pci_devs):
def _attach_pci_devices(self, dom, pci_devs):
def _set_host_enabled(self, enabled, disable_reason=DISABLE_REASON_UNDEFINED):
def get_host_capabilities(self):
def get_host_uuid(self):
def get_host_cpu_for_guest(self):
def get_guest_cpu_config(self):
def get_guest_disk_config(self, instance, name, disk_mapping, inst_type, image_type=None):
def get_guest_storage_config(self, instance, image_meta, disk_info, rescue, block_device_info, inst_type):
def get_guest_config_sysinfo(self, instance):
def get_guest_pci_device(self, pci_device):
def get_guest_config(self, instance, network_info, image_meta, disk_info, rescue=None, block_device_info=None):
def to_xml(self, context, instance, network_info, disk_info, image_meta=None, rescue=None, block_device_info=None, write_to_disk=False):
def _lookup_by_id(self, instance_id):
def _lookup_by_name(self, instance_name):
def get_info(self, instance):
def _create_domain(self, xml=None, domain=None, instance=None, launch_flags=0, power_on=True):
def _neutron_failed_callback(self, event_name, instance):
def _get_neutron_events(self, network_info):
def _conn_supports_start_paused():
def _create_domain_and_network(self, context, xml, instance, network_info, block_device_info=None, power_on=True, reboot=False, vifs_already_plugged=False):
def get_all_block_devices(self):
def get_disks(self, instance_name):
def get_interfaces(self, xml):
def get_vcpu_total(self):
def get_memory_mb_total(self):
def get_local_gb_info():
def get_vcpu_used(self):
def get_memory_mb_used(self):
def get_hypervisor_type(self):
def get_hypervisor_version(self):
def get_hypervisor_hostname(self):
def get_instance_capabilities(self):
def get_cpu_info(self):
def _get_pcidev_info(self, devname):
def _get_device_type(cfgdev):
def _pci_device_assignable(self, device):
def get_pci_passthrough_devices(self):
def get_all_volume_usage(self, context, compute_host_bdms):
def block_stats(self, instance_name, disk):
def interface_stats(self, instance_name, interface):
def get_console_pool_info(self, console_type):
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_available_resource(self, nodename):
def check_instance_shared_storage_local(self, context, instance):
def check_instance_shared_storage_remote(self, context, data):
def check_instance_shared_storage_cleanup(self, context, data):
def check_can_live_migrate_destination(self, context, instance, src_compute_info, dst_compute_info, block_migration=False, disk_over_commit=False):
def check_can_live_migrate_destination_cleanup(self, context, dest_check_data):
def check_can_live_migrate_source(self, context, instance, dest_check_data):
def _assert_dest_node_has_enough_disk(self, context, instance, available_mb, disk_over_commit):
def _compare_cpu(self, cpu_info):
def _create_shared_storage_test_file(self):
def _check_shared_storage_test_file(self, filename):
def _cleanup_shared_storage_test_file(self, filename):
def ensure_filtering_rules_for_instance(self, instance, network_info, time_module=None):
def filter_defer_apply_on(self):
def filter_defer_apply_off(self):
def live_migration(self, context, instance, dest, post_method, recover_method, block_migration=False, migrate_data=None):
def _live_migration(self, context, instance, dest, post_method, recover_method, block_migration=False, migrate_data=None):
def wait_for_live_migration():
def _fetch_instance_kernel_ramdisk(self, context, instance):
def rollback_live_migration_at_destination(self, context, instance, network_info, block_device_info):
def pre_live_migration(self, context, instance, block_device_info, network_info, disk_info, migrate_data=None):
def _create_images_and_backing(self, context, instance, instance_dir, disk_info_json):
def post_live_migration(self, context, instance, block_device_info, migrate_data=None):
def post_live_migration_at_destination(self, context, instance, network_info, block_migration, block_device_info=None):
def get_instance_disk_info(self, instance_name, xml=None, block_device_info=None):
def get_disk_over_committed_size_total(self):
def unfilter_instance(self, instance, network_info):
def get_host_stats(self, refresh=False):
def get_host_cpu_stats(self):
def get_host_uptime(self, host):
def manage_image_cache(self, context, all_instances):
def _cleanup_remote_migration(self, dest, inst_base, inst_base_resize, shared_storage=False):
def _is_storage_shared_with(self, dest, inst_base):
def migrate_disk_and_power_off(self, context, instance, dest, flavor, network_info, block_device_info=None):
def _wait_for_running(self, instance):
def finish_migration(self, context, migration, instance, disk_info, network_info, image_meta, resize_instance, block_device_info=None, power_on=True):
def _cleanup_failed_migration(self, inst_base):
def finish_revert_migration(self, context, instance, network_info, block_device_info=None, power_on=True):
def confirm_migration(self, migration, instance, network_info):
def get_diagnostics(self, instance):
def get_io_devices(xml_doc):
def instance_on_disk(self, instance):
def inject_network_info(self, instance, nw_info):
def _delete_instance_files(self, instance):
def delete_instance_files(self, instance):
def need_legacy_block_device_info(self):
def default_root_device_name(self, instance, image_meta, root_bdm):
def default_device_names_for_instance(self, instance, root_device_name, *block_device_lists):
class HostState(object):
def __init__(self, driver):
def get_host_stats(self, refresh=False):
def update_status(self):
def _get_disk_available_least():
\OpenStack\nova-2014.1\nova\virt\libvirt\firewall.py
class NWFilterFirewall(base_firewall.FirewallDriver):
def __init__(self, virtapi, get_connection, **kwargs):
def apply_instance_filter(self, instance, network_info):
def _get_connection(self):
def nova_no_nd_reflection_filter():
def nova_dhcp_filter():
def setup_basic_filtering(self, instance, network_info):
def _get_instance_filter_parameters(self, vif):
def format_parameter(parameter, value):
def _get_instance_filter_xml(self, instance, filters, vif):
def get_base_filter_list(self, instance, allow_dhcp):
def _ensure_static_filters(self):
def _filter_container(self, name, filters):
def _define_filter(self, xml):
def unfilter_instance(self, instance, network_info):
def _instance_filter_name(instance, nic_id=None):
def instance_filter_exists(self, instance, network_info):
class IptablesFirewallDriver(base_firewall.IptablesFirewallDriver):
def __init__(self, virtapi, execute=None, **kwargs):
def setup_basic_filtering(self, instance, network_info):
def apply_instance_filter(self, instance, network_info):
def unfilter_instance(self, instance, network_info):
def instance_filter_exists(self, instance, network_info):
\OpenStack\nova-2014.1\nova\virt\libvirt\imagebackend.py
class Image(object):
def __init__(self, source_type, driver_format, is_block_dev=False):
def create_image(self, prepare_template, base, size, *args, **kwargs):
def libvirt_info(self, disk_bus, disk_dev, device_type, cache_mode, extra_specs, hypervisor_version):
def check_image_exists(self):
def cache(self, fetch_func, filename, size=None, *args, **kwargs):
def fetch_func_sync(target, *args, **kwargs):
def _can_fallocate(self):
def verify_base_size(base, size, base_size=0):
def snapshot_extract(self, target, out_format):
def _get_driver_format(self):
def resolve_driver_format(self):
def _dict_from_line(line):
def write_to_disk_info_file():
class Raw(Image):
def __init__(self, instance=None, disk_name=None, path=None):
def _get_driver_format(self):
def correct_format(self):
def create_image(self, prepare_template, base, size, *args, **kwargs):
def copy_raw_image(base, target, size):
def snapshot_extract(self, target, out_format):
class Qcow2(Image):
def __init__(self, instance=None, disk_name=None, path=None):
def create_image(self, prepare_template, base, size, *args, **kwargs):
def copy_qcow2_image(base, target, size):
def snapshot_extract(self, target, out_format):
class Lvm(Image):
def escape(filename):
def __init__(self, instance=None, disk_name=None, path=None):
def _can_fallocate(self):
def create_image(self, prepare_template, base, size, *args, **kwargs):
def create_lvm_image(base, size):
def remove_volume_on_error(self, path):
def snapshot_extract(self, target, out_format):
class RBDVolumeProxy(object):
def __init__(self, driver, name, pool=None):
def __enter__(self):
def __exit__(self, type_, value, traceback):
def __getattr__(self, attrib):
def ascii_str(s):
class Rbd(Image):
def __init__(self, instance=None, disk_name=None, path=None, **kwargs):
def _connect_to_rados(self, pool=None):
def _disconnect_from_rados(self, client, ioctx):
def _supports_layering(self):
def _ceph_args(self):
def _get_mon_addrs(self):
def libvirt_info(self, disk_bus, disk_dev, device_type, cache_mode, extra_specs, hypervisor_version):
def _can_fallocate(self):
def check_image_exists(self):
def _resize(self, volume_name, size):
def create_image(self, prepare_template, base, size, *args, **kwargs):
def snapshot_extract(self, target, out_format):
class Backend(object):
def __init__(self, use_cow):
def backend(self, image_type=None):
def image(self, instance, disk_name, image_type=None):
def snapshot(self, disk_path, image_type=None):
\OpenStack\nova-2014.1\nova\virt\libvirt\imagecache.py
def get_cache_fname(images, key):
def get_info_filename(base_path):
def is_valid_info_file(path):
def _read_possible_json(serialized, info_file):
def read_stored_info(target, field=None, timestamped=False):
def write_stored_info(target, field=None, value=None):
def write_file(info_file, field, value):
def _hash_file(filename):
def read_stored_checksum(target, timestamped=True):
def write_stored_checksum(target):
class ImageCacheManager(imagecache.ImageCacheManager):
def __init__(self):
def _reset_state(self):
def _store_image(self, base_dir, ent, original=False):
def _list_base_images(self, base_dir):
def _list_backing_images(self):
def _find_base_file(self, base_dir, fingerprint):
def _verify_checksum(self, img_id, base_file, create_if_missing=True):
def inner_verify_checksum():
def _remove_base_file(self, base_file):
def _handle_base_image(self, img_id, base_file):
def _age_and_verify_cached_images(self, context, all_instances, base_dir):
def _get_base(self):
def update(self, context, all_instances):
\OpenStack\nova-2014.1\nova\virt\libvirt\utils.py
def execute(*args, **kwargs):
def get_iscsi_initiator():
def get_fc_hbas():
def get_fc_hbas_info():
def get_fc_wwpns():
def get_fc_wwnns():
def create_image(disk_format, path, size):
def create_cow_image(backing_file, path, size=None):
def create_lvm_image(vg, lv, size, sparse=False):
def import_rbd_image(*args):
def _run_rbd(*args, **kwargs):
def list_rbd_volumes(pool):
def remove_rbd_volumes(pool, *names):
def get_volume_group_info(vg):
def list_logical_volumes(vg):
def logical_volume_info(path):
def logical_volume_size(path):
def _zero_logical_volume(path, volume_size):
def clear_logical_volume(path):
def remove_logical_volumes(*paths):
def pick_disk_driver_name(hypervisor_version, is_block_dev=False):
def get_disk_size(path):
def get_disk_backing_file(path, basename=True):
def copy_image(src, dest, host=None):
def write_to_file(path, contents, umask=None):
def chown(path, owner):
def extract_snapshot(disk_path, source_fmt, out_path, dest_fmt):
def load_file(path):
def file_open(*args, **kwargs):
def file_delete(path):
def find_disk(virt_dom):
def get_disk_type(path):
def get_fs_info(path):
def fetch_image(context, target, image_id, user_id, project_id, max_size=0):
def get_instance_path(instance, forceold=False, relative=False):
def get_arch(image_meta):
def is_mounted(mount_path, source=None):
\OpenStack\nova-2014.1\nova\virt\libvirt\vif.py
def is_vif_model_valid_for_virt(virt_type, vif_model):
class LibvirtBaseVIFDriver(object):
def __init__(self, get_connection):
def has_libvirt_version(self, want):
def get_vif_devname(self, vif):
def get_vif_devname_with_prefix(self, vif, prefix):
def get_config(self, instance, vif, image_meta, inst_type):
def plug(self, instance, vif):
def unplug(self, instance, vif):
class LibvirtGenericVIFDriver(LibvirtBaseVIFDriver):
def get_bridge_name(self, vif):
def get_ovs_interfaceid(self, vif):
def get_br_name(self, iface_id):
def get_veth_pair_names(self, iface_id):
def get_firewall_required(self, vif):
def get_config_bridge(self, instance, vif, image_meta, inst_type):
def get_config_ovs_ethernet(self, instance, vif, image_meta, inst_type):
def get_config_ovs_bridge(self, instance, vif, image_meta, inst_type):
def get_config_ovs_hybrid(self, instance, vif, image_meta, inst_type):
def get_config_ovs(self, instance, vif, image_meta, inst_type):
def get_config_ivs_hybrid(self, instance, vif, image_meta, inst_type):
def get_config_ivs_ethernet(self, instance, vif, image_meta, inst_type):
def get_config_ivs(self, instance, vif, image_meta, inst_type):
def get_config_802qbg(self, instance, vif, image_meta, inst_type):
def get_config_802qbh(self, instance, vif, image_meta, inst_type):
def get_config_iovisor(self, instance, vif, image_meta, inst_type):
def get_config_midonet(self, instance, vif, image_meta, inst_type):
def get_config_mlnx_direct(self, instance, vif, image_meta, inst_type):
def get_config(self, instance, vif, image_meta, inst_type):
def plug_bridge(self, instance, vif):
def plug_ovs_ethernet(self, instance, vif):
def plug_ovs_bridge(self, instance, vif):
def plug_ovs_hybrid(self, instance, vif):
def plug_ovs(self, instance, vif):
def plug_ivs_ethernet(self, instance, vif):
def plug_ivs_hybrid(self, instance, vif):
def plug_ivs(self, instance, vif):
def plug_mlnx_direct(self, instance, vif):
def plug_802qbg(self, instance, vif):
def plug_802qbh(self, instance, vif):
def plug_midonet(self, instance, vif):
def plug_iovisor(self, instance, vif):
def plug(self, instance, vif):
def unplug_bridge(self, instance, vif):
def unplug_ovs_ethernet(self, instance, vif):
def unplug_ovs_bridge(self, instance, vif):
def unplug_ovs_hybrid(self, instance, vif):
def unplug_ovs(self, instance, vif):
def unplug_ivs_ethernet(self, instance, vif):
def unplug_ivs_hybrid(self, instance, vif):
def unplug_ivs(self, instance, vif):
def unplug_mlnx_direct(self, instance, vif):
def unplug_802qbg(self, instance, vif):
def unplug_802qbh(self, instance, vif):
def unplug_midonet(self, instance, vif):
def unplug_iovisor(self, instance, vif):
def unplug(self, instance, vif):
class _LibvirtDeprecatedDriver(LibvirtGenericVIFDriver):
def __init__(self, *args, **kwargs):
class LibvirtBridgeDriver(_LibvirtDeprecatedDriver):
class LibvirtOpenVswitchDriver(_LibvirtDeprecatedDriver):
class LibvirtHybridOVSBridgeDriver(_LibvirtDeprecatedDriver):
class LibvirtOpenVswitchVirtualPortDriver(_LibvirtDeprecatedDriver):
class NeutronLinuxBridgeVIFDriver(_LibvirtDeprecatedDriver):
\OpenStack\nova-2014.1\nova\virt\libvirt\volume.py
class LibvirtBaseVolumeDriver(object):
def __init__(self, connection, is_block_dev):
def connect_volume(self, connection_info, disk_info):
def disconnect_volume(self, connection_info, disk_dev):
class LibvirtVolumeDriver(LibvirtBaseVolumeDriver):
def __init__(self, connection):
def connect_volume(self, connection_info, disk_info):
class LibvirtFakeVolumeDriver(LibvirtBaseVolumeDriver):
def __init__(self, connection):
def connect_volume(self, connection_info, disk_info):
class LibvirtNetVolumeDriver(LibvirtBaseVolumeDriver):
def __init__(self, connection):
def connect_volume(self, connection_info, disk_info):
class LibvirtISCSIVolumeDriver(LibvirtBaseVolumeDriver):
def __init__(self, connection):
def _run_iscsiadm(self, iscsi_properties, iscsi_command, **kwargs):
def _iscsiadm_update(self, iscsi_properties, property_key, property_value, **kwargs):
def _get_target_portals_from_iscsiadm_output(self, output):
def connect_volume(self, connection_info, disk_info):
def disconnect_volume(self, connection_info, disk_dev):
def _delete_device(self, device_path):
def _remove_multipath_device_descriptor(self, disk_descriptor):
def _disconnect_volume_multipath_iscsi(self, iscsi_properties, multipath_device):
def _connect_to_iscsi_portal(self, iscsi_properties):
def _disconnect_from_iscsi_portal(self, iscsi_properties):
def _get_multipath_device_name(self, single_path_device):
def _get_iscsi_devices(self):
def _delete_mpath(self, iscsi_properties, multipath_device, ips_iqns):
def _disconnect_mpath(self, iscsi_properties, ips_iqns):
def _get_multipath_iqn(self, multipath_device):
def _run_iscsiadm_bare(self, iscsi_command, **kwargs):
def _run_multipath(self, multipath_command, **kwargs):
def _rescan_iscsi(self):
def _rescan_multipath(self):
def _get_host_device(self, iscsi_properties):
def _reconnect(self, iscsi_properties):
class LibvirtISERVolumeDriver(LibvirtISCSIVolumeDriver):
def __init__(self, connection):
def _get_multipath_iqn(self, multipath_device):
def _get_host_device(self, iser_properties):
def _reconnect(self, iser_properties):
class LibvirtNFSVolumeDriver(LibvirtBaseVolumeDriver):
def __init__(self, connection):
def connect_volume(self, connection_info, disk_info):
def disconnect_volume(self, connection_info, disk_dev):
def _ensure_mounted(self, nfs_export, options=None):
def _mount_nfs(self, mount_path, nfs_share, options=None, ensure=False):
class LibvirtAOEVolumeDriver(LibvirtBaseVolumeDriver):
def __init__(self, connection):
def _aoe_discover(self):
def _aoe_revalidate(self, aoedev):
def connect_volume(self, connection_info, mount_device):
def _wait_for_device_discovery(aoedevpath, mount_device):
class LibvirtGlusterfsVolumeDriver(LibvirtBaseVolumeDriver):
def __init__(self, connection):
def connect_volume(self, connection_info, mount_device):
def disconnect_volume(self, connection_info, disk_dev):
def _ensure_mounted(self, glusterfs_export, options=None):
def _mount_glusterfs(self, mount_path, glusterfs_share, options=None, ensure=False):
class LibvirtFibreChannelVolumeDriver(LibvirtBaseVolumeDriver):
def __init__(self, connection):
def _get_pci_num(self, hba):
def connect_volume(self, connection_info, disk_info):
def _wait_for_device_discovery(host_devices, mount_device):
def disconnect_volume(self, connection_info, mount_device):
class LibvirtScalityVolumeDriver(LibvirtBaseVolumeDriver):
def __init__(self, connection):
def connect_volume(self, connection_info, disk_info):
def _check_prerequisites(self):
def _mount_sofs(self):
\OpenStack\nova-2014.1\nova\virt\libvirt\__init__.py
\OpenStack\nova-2014.1\nova\virt\netutils.py
def get_net_and_mask(cidr):
def get_net_and_prefixlen(cidr):
def get_ip_version(cidr):
def _get_first_network(network, version):
def get_injected_network_template(network_info, use_ipv6=CONF.use_ipv6, template=CONF.injected_network_template):
def build_template(template, nets, ipv6_is_available):
\OpenStack\nova-2014.1\nova\virt\storage_users.py
def register_storage_use(storage_path, hostname):
def get_storage_users(storage_path):
\OpenStack\nova-2014.1\nova\virt\virtapi.py
class VirtAPI(object):
def instance_update(self, context, instance_uuid, updates):
def provider_fw_rule_get_all(self, context):
def agent_build_get_by_triple(self, context, hypervisor, os, architecture):
def wait_for_instance_event(self, instance, event_names, deadline=300, error_callback=None):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\driver.py
class VMwareESXDriver(driver.ComputeDriver):
def _do_deprecation_warning(self):
def __init__(self, virtapi, read_only=False, scheme="https"):
def host_state(self):
def init_host(self, host):
def cleanup_host(self, host):
def list_instances(self):
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=None):
def snapshot(self, context, instance, name, update_task_state):
def reboot(self, context, instance, network_info, reboot_type, block_device_info=None, bad_volumes_callback=None):
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 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 unrescue(self, instance, network_info):
def power_off(self, instance):
def power_on(self, context, instance, network_info, block_device_info=None):
def resume_state_on_host_boot(self, context, instance, network_info, block_device_info=None):
def poll_rebooting_instances(self, timeout, instances):
def get_info(self, instance):
def get_diagnostics(self, instance):
def get_vnc_console(self, context, instance):
def get_volume_connector(self, instance):
def get_host_ip_addr(self):
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_resources(self, host_stats):
def get_available_resource(self, nodename):
def update_host_status(self):
def get_host_stats(self, refresh=False):
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):
def inject_network_info(self, instance, network_info):
def list_instance_uuids(self):
def manage_image_cache(self, context, all_instances):
class VMwareVCDriver(VMwareESXDriver):
def _do_deprecation_warning(self):
def __init__(self, virtapi, read_only=False, scheme="https"):
def list_instances(self):
def migrate_disk_and_power_off(self, context, instance, dest, flavor, network_info, 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 live_migration(self, context, 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 get_vnc_console(self, context, instance):
def _update_resources(self):
def _create_nodename(self, mo_id, display_name):
def _get_resource_for_node(self, nodename):
def _get_vmops_for_compute_node(self, nodename):
def _get_volumeops_for_compute_node(self, nodename):
def _get_vc_state_for_compute_node(self, nodename):
def get_available_resource(self, nodename):
def get_available_nodes(self, refresh=False):
def get_host_stats(self, refresh=True):
def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=None):
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_volume_connector(self, instance):
def snapshot(self, context, instance, name, update_task_state):
def reboot(self, context, instance, network_info, reboot_type, block_device_info=None, bad_volumes_callback=None):
def destroy(self, context, instance, network_info, block_device_info=None, destroy_disks=True):
def pause(self, instance):
def unpause(self, instance):
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 unrescue(self, instance, network_info):
def power_off(self, instance):
def power_on(self, context, instance, network_info, block_device_info=None):
def poll_rebooting_instances(self, timeout, instances):
def get_info(self, instance):
def get_diagnostics(self, instance):
def host_power_action(self, host, action):
def host_maintenance_mode(self, host, mode):
def set_host_enabled(self, host, enabled):
def inject_network_info(self, instance, network_info):
def manage_image_cache(self, context, all_instances):
class VMwareAPISession(object):
def __init__(self, host_ip=CONF.vmware.host_ip, username=CONF.vmware.host_username, password=CONF.vmware.host_password, retry_count=CONF.vmware.api_retry_count, scheme="https"):
def _get_vim_object(self):
def _create_session(self):
def _is_vim_object(self, module):
def _session_is_active(self):
def _call_method(self, module, method, *args, **kwargs):
def _get_vim(self):
def _stop_loop(self, loop):
def _wait_for_task(self, task_ref):
def _poll_task(self, task_ref, done):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\ds_util.py
def build_datastore_path(datastore_name, path):
def split_datastore_path(datastore_path):
def file_delete(session, datastore_path, dc_ref):
def file_move(session, dc_ref, src_file, dst_file):
def file_exists(session, ds_browser, ds_path, file_name):
def mkdir(session, ds_path, dc_ref):
def get_sub_folders(session, ds_browser, ds_path):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\error_util.py
class VimException(Exception):
def __init__(self, exception_summary, excep):
def __str__(self):
class SessionOverLoadException(VimException):
class SessionConnectionException(VimException):
class VimAttributeError(VimException):
class VimFaultException(Exception):
def __init__(self, fault_list, excep):
def __str__(self):
class FaultCheckers(object):
def retrievepropertiesex_fault_checker(resp_obj):
class VMwareDriverException(exception.NovaException):
class VMwareDriverConfigurationException(VMwareDriverException):
class UseLinkedCloneConfigurationFault(VMwareDriverConfigurationException):
class MissingParameter(VMwareDriverException):
class AlreadyExistsException(VMwareDriverException):
class CannotDeleteFileException(VMwareDriverException):
class FileAlreadyExistsException(VMwareDriverException):
class FileFaultException(VMwareDriverException):
class FileLockedException(VMwareDriverException):
class FileNotFoundException(VMwareDriverException):
class InvalidPropertyException(VMwareDriverException):
class NotAuthenticatedException(VMwareDriverException):
def get_fault_class(name):
\OpenStack\nova-2014.1\nova\virt\vmwareapi\fake.py
def log_db_contents(msg=None):
def reset(vc=False):
def cleanup():
def _create_object(table, table_obj):
def _get_object(obj_ref):
def _get_objects(obj_type):
def _convert_to_array_of_mor(mors):
def _convert_to_array_of_opt_val(optvals):
class FakeRetrieveResult(object):
def __init__(self, token=None):
def add_object(self, object):
class MissingProperty(object):
def __init__(self, path='fake-path', message='fake_message', method_fault=None):
def _get_object_refs(obj_type):
def _update_object(table, table_obj):
class Prop(object):
def __init__(self, name=None, val=None):
class ManagedObjectReference(object):
def __init__(self, name="ManagedObject", value=None):
class ObjectContent(object):
def __init__(self, obj_ref, prop_list=None, missing_list=None):
class ManagedObject(object):
def __init__(self, mo_id_prefix="obj"):
def set(self, attr, val):
def get(self, attr):
def __setattr__(self, attr, val):
def __getattr__(self, attr):
def _generate_moid(self, prefix):
def __repr__(self):
class DataObject(object):
def __init__(self, obj_name=None):
def __repr__(self):
class HostInternetScsiHba(DataObject):
def __init__(self):
class FileAlreadyExists(DataObject):
def __init__(self):
class FileNotFound(DataObject):
def __init__(self):
class FileFault(DataObject):
def __init__(self):
OpenStack IndexPreviousNext
|
