@

Home 

OpenStack Study: nova

OpenStack Index

Previous

Next

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 Index

Previous

Next