@

Home 

OpenStack Study: nova

OpenStack Index

Previous

Next

def db_initial_version():

def db_version_control(version=None):

def _find_migrate_repo():

\OpenStack\nova-2014.1\nova\virt\baremetal\db\sqlalchemy\models.py

class BareMetalNode(BASE, models.NovaBase):

class BareMetalInterface(BASE, models.NovaBase):

\OpenStack\nova-2014.1\nova\virt\baremetal\db\sqlalchemy\session.py

def _create_facade_lazily():

def get_session(autocommit=True, expire_on_commit=False):

def get_engine():

\OpenStack\nova-2014.1\nova\virt\baremetal\db\sqlalchemy\__init__.py

\OpenStack\nova-2014.1\nova\virt\baremetal\db\__init__.py

\OpenStack\nova-2014.1\nova\virt\baremetal\driver.py

def _get_baremetal_node_by_instance_uuid(instance_uuid):

def _update_state(context, node, instance, state):

def get_power_manager(**kwargs):

class BareMetalDriver(driver.ComputeDriver):

    def __init__(self, virtapi, read_only=False):

    def instance(cls):

    def init_host(self, host):

    def get_hypervisor_type(self):

    def get_hypervisor_version(self):

    def list_instances(self):

    def _require_node(self, instance):

    def _attach_block_devices(self, instance, block_device_info):

    def _detach_block_devices(self, instance, block_device_info):

    def _start_firewall(self, instance, network_info):

    def _stop_firewall(self, instance, network_info):

    def macs_for_instance(self, instance):

    def _set_default_ephemeral_device(self, instance):

    def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=None):

    def _spawn(self, node, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=None):

    def rebuild(self, context, instance, image_meta, injected_files, admin_password, bdms, detach_block_devices, attach_block_devices, network_info=None, recreate=False, block_device_info=None, preserve_ephemeral=False):

    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):

    def cleanup(self, context, instance, network_info, block_device_info=None, destroy_disks=True):

    def power_off(self, instance, node=None):

    def power_on(self, context, instance, network_info, block_device_info=None, node=None):

    def get_volume_connector(self, instance):

    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_info(self, instance):

    def refresh_security_group_rules(self, security_group_id):

    def refresh_security_group_members(self, security_group_id):

    def refresh_provider_fw_rules(self):

    def _node_resource(self, node):

    def refresh_instance_security_rules(self, instance):

    def get_available_resource(self, nodename):

    def ensure_filtering_rules_for_instance(self, instance_ref, network_info):

    def unfilter_instance(self, instance_ref, network_info):

    def get_host_stats(self, refresh=False):

    def plug_vifs(self, instance, network_info):

    def _plug_vifs(self, instance, network_info, context=None):

    def _unplug_vifs(self, instance, network_info):

    def manage_image_cache(self, context, all_instances):

    def get_console_output(self, context, instance):

    def get_available_nodes(self, refresh=False):

    def dhcp_options_for_instance(self, instance):

\OpenStack\nova-2014.1\nova\virt\baremetal\fake.py

class FakeDriver(base.NodeDriver):

    def cache_images(self, context, node, instance, **kwargs):

    def destroy_images(self, context, node, instance):

    def activate_bootloader(self, context, node, instance, **kwargs):

    def deactivate_bootloader(self, context, node, instance):

    def activate_node(self, context, node, instance):

    def deactivate_node(self, context, node, instance):

    def get_console_output(self, node, instance):

class FakePowerManager(base.PowerManager):

    def __init__(self, **kwargs):

class FakeFirewallDriver(firewall.NoopFirewallDriver):

    def __init__(self):

class FakeVifDriver(object):

    def __init__(self):

    def plug(self, instance, vif):

    def unplug(self, instance, vif):

class FakeVolumeDriver(object):

    def __init__(self, virtapi):

    def attach_volume(self, connection_info, instance, mountpoint):

    def detach_volume(self, connection_info, instance, mountpoint):

\OpenStack\nova-2014.1\nova\virt\baremetal\iboot_pdu.py

class IBootManager(base.PowerManager):

    def __init__(self, **kwargs):

    def _create_connection(self):

    def _switch(self, relay_id, enabled):

    def _get_relay(self, relay_id):

    def activate_node(self):

    def reboot_node(self):

    def deactivate_node(self):

    def is_power_on(self):

\OpenStack\nova-2014.1\nova\virt\baremetal\ipmi.py

def _make_password_file(password):

def _get_console_pid_path(node_id):

def _get_console_pid(node_id):

class IPMI(base.PowerManager):

    def __init__(self, node, **kwargs):

    def _exec_ipmitool(self, command):

    def _power_on(self):

        def _wait_for_power_on():

    def _power_off(self):

        def _wait_for_power_off():

    def _set_pxe_for_next_boot(self):

    def activate_node(self):

    def reboot_node(self):

    def deactivate_node(self):

    def is_power_on(self):

    def start_console(self):

    def stop_console(self):

\OpenStack\nova-2014.1\nova\virt\baremetal\pxe.py

def build_pxe_network_config(network_info):

def build_pxe_config(deployment_id, deployment_key, deployment_iscsi_iqn, deployment_aki_path, deployment_ari_path, aki_path, ari_path, network_info):

def build_network_config(network_info):

def get_deploy_aki_id(flavor):

def get_deploy_ari_id(flavor):

def get_image_dir_path(instance):

def get_image_file_path(instance):

def get_pxe_config_file_path(instance):

def get_partition_sizes(instance):

def get_pxe_mac_path(mac):

def get_tftp_image_info(instance, flavor):

class PXE(base.NodeDriver):

    def __init__(self, virtapi):

    def _collect_mac_addresses(self, context, node):

    def _cache_tftp_images(self, context, instance, image_info):

    def _cache_image(self, context, instance, image_meta):

    def _inject_into_image(self, context, node, instance, network_info, injected_files=None, admin_password=None):

    def cache_images(self, context, node, instance, admin_password, image_meta, injected_files, network_info):

    def destroy_images(self, context, node, instance):

    def dhcp_options_for_instance(self, instance):

    def activate_bootloader(self, context, node, instance, network_info):

    def deactivate_bootloader(self, context, node, instance):

    def activate_node(self, context, node, instance):

        def _wait_for_deploy():

    def deactivate_node(self, context, node, instance):

\OpenStack\nova-2014.1\nova\virt\baremetal\tilera.py

def build_network_config(network_info):

def get_image_dir_path(instance):

def get_image_file_path(instance):

def get_tilera_nfs_path(node_id):

def get_partition_sizes(instance):

def get_tftp_image_info(instance):

class Tilera(base.NodeDriver):

    def __init__(self, virtapi):

    def _collect_mac_addresses(self, context, node):

    def _cache_tftp_images(self, context, instance, image_info):

    def _cache_image(self, context, instance, image_meta):

    def _inject_into_image(self, context, node, instance, network_info, injected_files=None, admin_password=None):

    def cache_images(self, context, node, instance, admin_password, image_meta, injected_files, network_info):

    def destroy_images(self, context, node, instance):

    def activate_bootloader(self, context, node, instance, network_info):

    def deactivate_bootloader(self, context, node, instance):

    def _iptables_set(self, node_ip, user_data):

    def activate_node(self, context, node, instance):

    def deactivate_node(self, context, node, instance):

\OpenStack\nova-2014.1\nova\virt\baremetal\tilera_pdu.py

class Pdu(base.PowerManager):

    def __init__(self, node, **kwargs):

    def _exec_pdutool(self, mode):

    def _is_power(self, state):

    def _power_on(self):

    def _power_off(self):

    def activate_node(self):

    def reboot_node(self):

    def deactivate_node(self):

    def is_power_on(self):

\OpenStack\nova-2014.1\nova\virt\baremetal\utils.py

def cache_image(context, target, image_id, user_id, project_id, clean=False):

def inject_into_image(image, key, net, metadata, admin_password, files, partition, use_cow=False):

def unlink_without_raise(path):

def rmtree_without_raise(path):

def write_to_file(path, contents):

def create_link_without_raise(source, link):

def random_alnum(count):

def map_network_interfaces(network_info, use_ipv6=False):

\OpenStack\nova-2014.1\nova\virt\baremetal\vif_driver.py

class BareMetalVIFDriver(object):

    def _after_plug(self, instance, vif, pif):

    def _after_unplug(self, instance, vif, pif):

    def plug(self, instance, vif):

    def unplug(self, instance, vif):

\OpenStack\nova-2014.1\nova\virt\baremetal\virtual_power_driver.py

def _normalize_mac(mac):

class VirtualPowerManager(base.PowerManager):

    def __init__(self, **kwargs):

    def _get_conn(self):

    def _set_connection(self):

    def _get_full_node_list(self):

    def _check_for_node(self):

    def activate_node(self):

    def reboot_node(self):

    def deactivate_node(self):

    def is_power_on(self):

    def _run_command(self, cmd, check_exit_code=True):

\OpenStack\nova-2014.1\nova\virt\baremetal\virtual_power_driver_settings.py

class vbox(object):

    def __init__(self):

class virsh(object):

    def __init__(self):

\OpenStack\nova-2014.1\nova\virt\baremetal\volume_driver.py

def _get_baremetal_node_by_instance_uuid(instance_uuid):

def _create_iscsi_export_tgtadm(path, tid, iqn):

def _allow_iscsi_tgtadm(tid, address):

def _delete_iscsi_export_tgtadm(tid):

def _show_tgtadm():

def _list_backingstore_path():

def _get_next_tid():

def _find_tid(iqn):

def _get_iqn(instance_name, mountpoint):

def _get_fixed_ips(instance):

class VolumeDriver(object):

    def __init__(self, virtapi):

    def get_volume_connector(self, instance):

    def attach_volume(self, connection_info, instance, mountpoint):

    def detach_volume(self, connection_info, instance, mountpoint):

class LibvirtVolumeDriver(VolumeDriver):

    def __init__(self, virtapi):

    def _volume_driver_method(self, method_name, connection_info, *args, **kwargs):

    def attach_volume(self, connection_info, instance, mountpoint):

    def _connect_volume(self, connection_info, disk_info):

    def _publish_iscsi(self, instance, mountpoint, fixed_ips, device_path):

    def detach_volume(self, connection_info, instance, mountpoint):

    def _disconnect_volume(self, connection_info, disk_dev):

    def _depublish_iscsi(self, instance, mountpoint):

    def get_all_block_devices(self):

    def get_hypervisor_version(self):

\OpenStack\nova-2014.1\nova\virt\baremetal\__init__.py

\OpenStack\nova-2014.1\nova\virt\block_device.py

class _NotTransformable(Exception):

class _InvalidType(_NotTransformable):

class _NoLegacy(Exception):

    def wrapped(obj, context, *args, **kwargs):

class DriverBlockDevice(dict):

    def __init__(self, bdm):

    def __getattr__(self, name):

    def __setattr__(self, name, value):

    def _transform(self):

    def legacy(self):

    def attach(self, **kwargs):

    def save(self, context):

class DriverSwapBlockDevice(DriverBlockDevice):

    def _transform(self):

class DriverEphemeralBlockDevice(DriverBlockDevice):

    def _transform(self):

    def legacy(self, num=0):

class DriverVolumeBlockDevice(DriverBlockDevice):

    def _transform(self):

    def attach(self, context, instance, volume_api, virt_driver, do_check_attach=True, do_driver_attach=False):

    def refresh_connection_info(self, context, instance, volume_api, virt_driver):

    def save(self, context):

class DriverSnapshotBlockDevice(DriverVolumeBlockDevice):

    def attach(self, context, instance, volume_api, virt_driver, wait_func=None):

class DriverImageBlockDevice(DriverVolumeBlockDevice):

    def attach(self, context, instance, volume_api, virt_driver, wait_func=None):

def _convert_block_devices(device_type, block_device_mapping):

    def _is_transformable(bdm):

def attach_block_devices(block_device_mapping, *attach_args, **attach_kwargs):

    def _log_and_attach(bdm):

def refresh_conn_infos(block_device_mapping, *refresh_args, **refresh_kwargs):

def legacy_block_devices(block_device_mapping):

    def _has_legacy(bdm):

def get_swap(transformed_list):

def is_implemented(bdm):

\OpenStack\nova-2014.1\nova\virt\configdrive.py

class ConfigDriveBuilder(object):

    def __init__(self, instance_md=None):

    def __enter__(self):

    def __exit__(self, exctype, excval, exctb):

    def _add_file(self, path, data):

    def add_instance_metadata(self, instance_md):

    def _make_iso9660(self, path):

    def _make_vfat(self, path):

    def make_drive(self, path):

    def cleanup(self):

def required_by(instance):

\OpenStack\nova-2014.1\nova\virt\cpu.py

def get_cpuset_ids():

\OpenStack\nova-2014.1\nova\virt\disk\api.py

def get_fs_type_for_os_type(os_type):

def mkfs(os_type, fs_label, target, run_as_root=True):

def resize2fs(image, check_exit_code=False, run_as_root=False):

def get_disk_size(path):

def extend(image, size, use_cow=False):

 def safe_resize2fs(dev, run_as_root=False, finally_call=lambda:

def can_resize_image(image, size):

def is_image_partitionless(image, use_cow=False):

class _DiskImage(object):

    def __init__(self, image, partition=None, use_cow=False, mount_dir=None):

    def _device_for_path(path):

    def _reset(self, device):

    def errors(self):

    def mount(self):

    def umount(self):

    def teardown(self):

def inject_data(image, key=None, net=None, metadata=None, admin_password=None, files=None, partition=None, use_cow=False, mandatory=()):

def setup_container(image, container_dir, use_cow=False):

def teardown_container(container_dir, container_root_device=None):

def clean_lxc_namespace(container_dir):

def inject_data_into_fs(fs, key, net, metadata, admin_password, files, mandatory=()):

def _inject_files_into_fs(files, fs):

def _inject_file_into_fs(fs, path, contents, append=False):

def _inject_metadata_into_fs(metadata, fs):

def _setup_selinux_for_keys(fs, sshdir):

def _inject_key_into_fs(key, fs):

def _inject_net_into_fs(net, fs):

def _inject_admin_password_into_fs(admin_passwd, fs):

def _generate_salt():

def _set_passwd(username, admin_passwd, passwd_data, shadow_data):

\OpenStack\nova-2014.1\nova\virt\disk\mount\api.py

class Mount(object):

    def instance_for_format(imgfile, mountdir, partition, imgfmt):

    def instance_for_device(imgfile, mountdir, partition, device):

    def __init__(self, image, mount_dir, partition=None, device=None):

    def reset_dev(self):

    def get_dev(self):

    def _get_dev_retry_helper(self):

    def _inner_get_dev(self):

    def unget_dev(self):

    def map_dev(self):

    def unmap_dev(self):

    def mnt_dev(self):

    def unmnt_dev(self):

    def flush_dev(self):

    def do_mount(self):

    def do_umount(self):

    def do_teardown(self):

\OpenStack\nova-2014.1\nova\virt\disk\mount\loop.py

class LoopMount(api.Mount):

    def _inner_get_dev(self):

    def get_dev(self):

    def unget_dev(self):

\OpenStack\nova-2014.1\nova\virt\disk\mount\nbd.py

class NbdMount(api.Mount):

    def _detect_nbd_devices(self):

    def _find_unused(self, devices):

    def _allocate_nbd(self):

    def _inner_get_dev(self):

    def get_dev(self):

    def unget_dev(self):

    def flush_dev(self):

\OpenStack\nova-2014.1\nova\virt\disk\mount\__init__.py

\OpenStack\nova-2014.1\nova\virt\disk\vfs\api.py

class VFS(object):

    def instance_for_image(imgfile, imgfmt, partition):

    def __init__(self, imgfile, imgfmt, partition):

    def setup(self):

    def teardown(self):

    def make_path(self, path):

    def append_file(self, path, content):

    def replace_file(self, path, content):

    def read_file(self, path):

    def has_file(self, path):

    def set_permissions(self, path, mode):

    def set_ownership(self, path, user, group):

\OpenStack\nova-2014.1\nova\virt\disk\vfs\guestfs.py

class VFSGuestFS(vfs.VFS):

    def __init__(self, imgfile, imgfmt='raw', partition=None):

    def setup_os(self):

    def setup_os_static(self):

    def setup_os_inspect(self):

    def setup_os_root(self, root):

    def setup(self):

    def teardown(self):

    def _canonicalize_path(path):

    def make_path(self, path):

    def append_file(self, path, content):

    def replace_file(self, path, content):

    def read_file(self, path):

    def has_file(self, path):

    def set_permissions(self, path, mode):

    def set_ownership(self, path, user, group):

\OpenStack\nova-2014.1\nova\virt\disk\vfs\localfs.py

class VFSLocalFS(vfs.VFS):

    def _canonical_path(self, path):

    def __init__(self, imgfile, imgfmt="raw", partition=None, imgdir=None):

    def setup(self):

    def teardown(self):

    def make_path(self, path):

    def append_file(self, path, content):

    def replace_file(self, path, content):

    def read_file(self, path):

    def has_file(self, path):

    def set_permissions(self, path, mode):

    def set_ownership(self, path, user, group):

\OpenStack\nova-2014.1\nova\virt\disk\vfs\__init__.py

\OpenStack\nova-2014.1\nova\virt\disk\__init__.py

\OpenStack\nova-2014.1\nova\virt\driver.py

def driver_dict_from_config(named_driver_config, *args, **kwargs):

def block_device_info_get_root(block_device_info):

def block_device_info_get_swap(block_device_info):

def swap_is_usable(swap):

def block_device_info_get_ephemerals(block_device_info):

def block_device_info_get_mapping(block_device_info):

class ComputeDriver(object):

    def __init__(self, virtapi):

    def init_host(self, host):

    def cleanup_host(self, host):

    def get_info(self, instance):

    def get_num_instances(self):

    def instance_exists(self, instance_id):

    def estimate_instance_overhead(self, instance_info):

    def list_instances(self):

    def list_instance_uuids(self):

    def rebuild(self, context, instance, image_meta, injected_files, admin_password, bdms, detach_block_devices, attach_block_devices, network_info=None, recreate=False, block_device_info=None, preserve_ephemeral=False):

    def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info=None, block_device_info=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 reboot(self, context, instance, network_info, reboot_type, block_device_info=None, bad_volumes_callback=None):

    def get_console_pool_info(self, console_type):

    def get_console_output(self, context, instance):

    def get_vnc_console(self, context, instance):

    def get_spice_console(self, context, instance):

    def get_rdp_console(self, context, instance):

    def get_diagnostics(self, instance):

    def get_all_bw_counters(self, instances):

    def get_all_volume_usage(self, context, compute_host_bdms):

    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 swap_volume(self, old_connection_info, new_connection_info, instance, mountpoint):

    def attach_interface(self, instance, image_meta, vif):

    def detach_interface(self, instance, vif):

    def migrate_disk_and_power_off(self, context, instance, dest, flavor, network_info, block_device_info=None):

    def snapshot(self, context, instance, image_id, update_task_state):

    def finish_migration(self, context, migration, instance, disk_info, network_info, image_meta, resize_instance, block_device_info=None, power_on=True):

    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 pause(self, instance):

    def unpause(self, instance):

    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 set_bootable(self, instance, is_bootable):

    def unrescue(self, instance, network_info):

    def power_off(self, instance):

    def power_on(self, context, instance, network_info, block_device_info=None):

    def soft_delete(self, instance):

    def restore(self, instance):

    def get_available_resource(self, nodename):

    def pre_live_migration(self, ctxt, instance, block_device_info, network_info, disk_info, migrate_data=None):

    def live_migration(self, ctxt, instance_ref, dest, post_method, recover_method, block_migration=False, migrate_data=None):

    def rollback_live_migration_at_destination(self, ctxt, instance_ref, network_info, block_device_info):

    def post_live_migration(self, ctxt, instance_ref, block_device_info, migrate_data=None):

    def post_live_migration_at_destination(self, ctxt, instance_ref, network_info, block_migration=False, block_device_info=None):

    def check_instance_shared_storage_local(self, ctxt, instance):

    def check_instance_shared_storage_remote(self, ctxt, data):

    def check_instance_shared_storage_cleanup(self, ctxt, data):

    def check_can_live_migrate_destination(self, ctxt, instance_ref, src_compute_info, dst_compute_info, block_migration=False, disk_over_commit=False):

    def check_can_live_migrate_destination_cleanup(self, ctxt, dest_check_data):

    def check_can_live_migrate_source(self, ctxt, instance_ref, dest_check_data):

    def refresh_security_group_rules(self, security_group_id):

    def refresh_security_group_members(self, security_group_id):

    def refresh_provider_fw_rules(self):

    def refresh_instance_security_rules(self, instance):

    def reset_network(self, instance):

    def ensure_filtering_rules_for_instance(self, instance, network_info):

    def filter_defer_apply_on(self):

    def filter_defer_apply_off(self):

    def unfilter_instance(self, instance, network_info):

    def set_admin_password(self, context, instance, new_pass=None):

    def inject_file(self, instance, b64_path, b64_contents):

    def change_instance_metadata(self, context, instance, diff):

    def inject_network_info(self, instance, nw_info):

    def poll_rebooting_instances(self, timeout, instances):

    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 plug_vifs(self, instance, network_info):

    def unplug_vifs(self, instance, network_info):

    def get_host_stats(self, refresh=False):

    def get_host_cpu_stats(self):

    def block_stats(self, instance_name, disk_id):

    def interface_stats(self, instance_name, iface_id):

    def macs_for_instance(self, instance):

    def dhcp_options_for_instance(self, instance):

    def manage_image_cache(self, context, all_instances):

    def add_to_aggregate(self, context, aggregate, host, **kwargs):

    def remove_from_aggregate(self, context, aggregate, host, **kwargs):

    def undo_aggregate_operation(self, context, op, aggregate, host, set_error=True):

    def get_volume_connector(self, instance):

    def get_available_nodes(self, refresh=False):

    def node_is_available(self, nodename):

    def get_per_instance_usage(self):

    def instance_on_disk(self, instance):

    def register_event_listener(self, callback):

    def emit_event(self, event):

    def delete_instance_files(self, instance):

    def need_legacy_block_device_info(self):

    def volume_snapshot_create(self, context, instance, volume_id, create_info):

    def volume_snapshot_delete(self, context, instance, volume_id, snapshot_id, delete_info):

    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):

def load_compute_driver(virtapi, compute_driver=None):

def compute_driver_matches(match):

\OpenStack\nova-2014.1\nova\virt\event.py

class Event(object):

    def __init__(self, timestamp=None):

    def get_timestamp(self):

class InstanceEvent(Event):

    def __init__(self, uuid, timestamp=None):

    def get_instance_uuid(self):

class LifecycleEvent(InstanceEvent):

    def __init__(self, uuid, transition, timestamp=None):

    def get_transition(self):

\OpenStack\nova-2014.1\nova\virt\fake.py

def set_nodes(nodes):

def restore_nodes():

class FakeInstance(object):

    def __init__(self, name, state):

    def __getitem__(self, key):

class FakeDriver(driver.ComputeDriver):

    def __init__(self, virtapi, read_only=False):

    def init_host(self, host):

    def list_instances(self):

    def plug_vifs(self, instance, network_info):

    def unplug_vifs(self, instance, network_info):

    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 get_host_ip_addr():

    def set_admin_password(self, instance, new_pass):

    def inject_file(self, instance, b64_path, b64_contents):

    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 migrate_disk_and_power_off(self, context, instance, dest, flavor, network_info, block_device_info=None):

    def finish_revert_migration(self, context, instance, network_info, block_device_info=None, power_on=True):

    def post_live_migration_at_destination(self, context, instance, network_info, block_migration=False, block_device_info=None):

    def power_off(self, instance):

    def power_on(self, context, instance, network_info, block_device_info):

    def soft_delete(self, instance):

    def restore(self, instance):

    def pause(self, instance):

    def unpause(self, instance):

    def suspend(self, instance):

    def resume(self, context, instance, network_info, block_device_info=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 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 swap_volume(self, old_connection_info, new_connection_info, instance, mountpoint):

    def attach_interface(self, instance, image_meta, vif):

    def detach_interface(self, instance, vif):

    def get_info(self, instance):

    def get_diagnostics(self, instance_name):

    def get_all_bw_counters(self, instances):

    def get_all_volume_usage(self, context, compute_host_bdms):

    def get_host_cpu_stats(self):

    def block_stats(self, instance_name, disk_id):

    def interface_stats(self, instance_name, iface_id):

    def get_console_output(self, context, instance):

    def get_vnc_console(self, context, instance):

    def get_spice_console(self, context, instance):

    def get_rdp_console(self, context, instance):

    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 ensure_filtering_rules_for_instance(self, instance_ref, network_info):

    def get_instance_disk_info(self, instance_name):

    def live_migration(self, context, instance_ref, dest, post_method, recover_method, block_migration=False, migrate_data=None):

    def check_can_live_migrate_destination_cleanup(self, ctxt, dest_check_data):

    def check_can_live_migrate_destination(self, ctxt, instance_ref, src_compute_info, dst_compute_info, block_migration=False, disk_over_commit=False):

    def check_can_live_migrate_source(self, ctxt, instance_ref, dest_check_data):

    def finish_migration(self, context, migration, instance, disk_info, network_info, image_meta, resize_instance, block_device_info=None, power_on=True):

    def confirm_migration(self, migration, instance, network_info):

    def pre_live_migration(self, context, instance_ref, block_device_info, network_info, disk, migrate_data=None):

    def unfilter_instance(self, instance_ref, network_info):

    def test_remove_vm(self, instance_name):

    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_disk_available_least(self):

    def get_volume_connector(self, instance):

    def get_available_nodes(self, refresh=False):

    def instance_on_disk(self, instance):

    def list_instance_uuids(self):

class FakeVirtAPI(virtapi.VirtAPI):

    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\firewall.py

def load_driver(default, *args, **kwargs):

class FirewallDriver(object):

    def __init__(self, virtapi):

    def prepare_instance_filter(self, instance, network_info):

    def filter_defer_apply_on(self):

    def filter_defer_apply_off(self):

    def unfilter_instance(self, instance, network_info):

    def apply_instance_filter(self, instance, network_info):

    def refresh_security_group_rules(self, security_group_id):

    def refresh_security_group_members(self, security_group_id):

    def refresh_instance_security_rules(self, instance):

    def refresh_provider_fw_rules(self):

    def setup_basic_filtering(self, instance, network_info):

    def instance_filter_exists(self, instance, network_info):

class IptablesFirewallDriver(FirewallDriver):

    def __init__(self, virtapi, **kwargs):

    def setup_basic_filtering(self, instance, network_info):

    def apply_instance_filter(self, instance, network_info):

    def filter_defer_apply_on(self):

    def filter_defer_apply_off(self):

    def unfilter_instance(self, instance, network_info):

    def prepare_instance_filter(self, instance, network_info):

    def _create_filter(self, ips, chain_name):

    def _get_subnets(self, network_info, version):

    def _filters_for_instance(self, chain_name, network_info):

    def _add_filters(self, chain_name, ipv4_rules, ipv6_rules):

    def add_filters_for_instance(self, instance, inst_ipv4_rules, inst_ipv6_rules):

    def remove_filters_for_instance(self, instance):

    def _instance_chain_name(self, instance):

    def _do_basic_rules(self, ipv4_rules, ipv6_rules, network_info):

    def _do_dhcp_rules(self, ipv4_rules, network_info):

    def _do_project_network_rules(self, ipv4_rules, ipv6_rules, network_info):

    def _do_ra_rules(self, ipv6_rules, network_info):

    def _build_icmp_rule(self, rule, version):

    def _build_tcp_udp_rule(self, rule, version):

    def instance_rules(self, instance, network_info):

    def instance_filter_exists(self, instance, network_info):

    def refresh_security_group_members(self, security_group):

    def refresh_security_group_rules(self, security_group):

    def refresh_instance_security_rules(self, instance):

    def _inner_do_refresh_rules(self, instance, ipv4_rules, ipv6_rules):

    def do_refresh_security_group_rules(self, security_group):

    def do_refresh_instance_rules(self, instance):

    def refresh_provider_fw_rules(self):

    def _do_refresh_provider_fw_rules(self):

    def _purge_provider_fw_rules(self):

    def _build_provider_fw_rules(self):

    def _provider_rules(self):

class NoopFirewallDriver(object):

    def __init__(self, *args, **kwargs):

    def _noop(self, *args, **kwargs):

    def __getattr__(self, key):

    def instance_filter_exists(self, instance, network_info):

\OpenStack\nova-2014.1\nova\virt\hyperv\basevolumeutils.py

class BaseVolumeUtils(object):

    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):

    def get_iscsi_initiator(self):

    def volume_in_mapping(self, mount_device, block_device_info):

    def _get_drive_number_from_disk_path(self, disk_path):

    def get_session_id_from_mounted_disk(self, physical_drive_path):

    def get_device_number_for_target(self, target_iqn, target_lun):

    def get_target_from_disk_path(self, disk_path):

\OpenStack\nova-2014.1\nova\virt\hyperv\constants.py

\OpenStack\nova-2014.1\nova\virt\hyperv\driver.py

class HyperVDriver(driver.ComputeDriver):

    def __init__(self, virtapi):

    def init_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 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 get_info(self, instance):

    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 get_available_resource(self, nodename):

    def get_host_stats(self, refresh=False):

    def host_power_action(self, host, action):

    def snapshot(self, context, instance, name, update_task_state):

    def pause(self, instance):

    def unpause(self, instance):

    def suspend(self, instance):

    def resume(self, context, instance, network_info, block_device_info=None):

    def power_off(self, instance):

    def power_on(self, context, instance, network_info, block_device_info=None):

    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 pre_live_migration(self, context, instance, block_device_info, network_info, disk, migrate_data=None):

    def post_live_migration_at_destination(self, ctxt, instance_ref, network_info, block_migr=False, block_device_info=None):

    def check_can_live_migrate_destination(self, ctxt, instance_ref, src_compute_info, dst_compute_info, block_migration=False, disk_over_commit=False):

    def check_can_live_migrate_destination_cleanup(self, ctxt, dest_check_data):

    def check_can_live_migrate_source(self, ctxt, instance_ref, dest_check_data):

    def plug_vifs(self, instance, network_info):

    def unplug_vifs(self, instance, network_info):

    def ensure_filtering_rules_for_instance(self, instance_ref, network_info):

    def unfilter_instance(self, instance, network_info):

    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 get_host_ip_addr(self):

    def get_rdp_console(self, context, instance):

\OpenStack\nova-2014.1\nova\virt\hyperv\hostops.py

class HostOps(object):

    def __init__(self):

    def _get_cpu_info(self):

    def _get_memory_info(self):

    def _get_local_hdd_info_gb(self):

    def _get_hypervisor_version(self):

    def get_available_resource(self):

    def _update_stats(self):

    def get_host_stats(self, refresh=False):

    def host_power_action(self, host, action):

    def get_host_ip_addr(self):

\OpenStack\nova-2014.1\nova\virt\hyperv\hostutils.py

class HostUtils(object):

    def __init__(self):

    def get_cpus_info(self):

    def is_cpu_feature_present(self, feature_key):

    def get_memory_info(self):

    def get_volume_info(self, drive):

    def check_min_windows_version(self, major, minor, build=0):

    def get_windows_version(self):

    def get_local_ips(self):

\OpenStack\nova-2014.1\nova\virt\hyperv\imagecache.py

class ImageCache(object):

    def __init__(self):

    def _get_root_vhd_size_gb(self, instance):

    def _resize_and_cache_vhd(self, instance, vhd_path):

    def get_cached_image(self, context, instance):

        def fetch_image_if_not_existing():

\OpenStack\nova-2014.1\nova\virt\hyperv\livemigrationops.py

def check_os_version_requirement(function):

 def wrapper(self, *args, **kwds):

class LiveMigrationOps(object):

    def __init__(self):

    def live_migration(self, context, instance_ref, dest, post_method, recover_method, block_migration=False, migrate_data=None):

    def pre_live_migration(self, context, instance, block_device_info, network_info):

    def post_live_migration_at_destination(self, ctxt, instance_ref, network_info, block_migration):

    def check_can_live_migrate_destination(self, ctxt, instance_ref, src_compute_info, dst_compute_info, block_migration=False, disk_over_commit=False):

    def check_can_live_migrate_destination_cleanup(self, ctxt, dest_check_data):

    def check_can_live_migrate_source(self, ctxt, instance_ref, dest_check_data):

\OpenStack\nova-2014.1\nova\virt\hyperv\livemigrationutils.py

class LiveMigrationUtils(object):

    def __init__(self):

    def _get_conn_v2(self, host='localhost'):

    def check_live_migration_config(self):

    def _get_vm(self, conn_v2, vm_name):

    def _destroy_planned_vm(self, conn_v2_remote, planned_vm):

    def _check_existing_planned_vm(self, conn_v2_remote, vm):

    def _create_remote_planned_vm(self, conn_v2_local, conn_v2_remote, vm, rmt_ip_addr_list, dest_host):

    def _get_physical_disk_paths(self, vm_name):

    def _get_remote_disk_data(self, vmutils_remote, disk_paths, dest_host):

    def _update_planned_vm_disk_resources(self, vmutils_remote, conn_v2_remote, planned_vm, vm_name, disk_paths_remote):

    def _get_vhd_setting_data(self, vm):

    def _live_migrate_vm(self, conn_v2_local, vm, planned_vm, rmt_ip_addr_list, new_resource_setting_data, dest_host):

    def _get_remote_ip_address_list(self, conn_v2_remote, dest_host):

    def live_migrate_vm(self, vm_name, dest_host):

\OpenStack\nova-2014.1\nova\virt\hyperv\migrationops.py

class MigrationOps(object):

    def __init__(self):

    def _migrate_disk_files(self, instance_name, disk_files, dest):

    def _cleanup_failed_disk_migration(self, instance_path, revert_path, dest_path):

    def _check_target_flavor(self, instance, flavor):

    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 _revert_migration_files(self, instance_name):

    def finish_revert_migration(self, context, instance, network_info, block_device_info=None, power_on=True):

    def _merge_base_vhd(self, diff_vhd_path, base_vhd_path):

    def _check_resize_vhd(self, vhd_path, vhd_info, new_size):

    def _resize_vhd(self, vhd_path, new_size):

    def _check_base_disk(self, context, instance, diff_vhd_path, src_base_disk_path):

    def finish_migration(self, context, migration, instance, disk_info, network_info, image_meta, resize_instance=False, block_device_info=None, power_on=True):

\OpenStack\nova-2014.1\nova\virt\hyperv\networkutils.py

class NetworkUtils(object):

    def __init__(self):

    def get_external_vswitch(self, vswitch_name):

    def create_vswitch_port(self, vswitch_path, port_name):

    def vswitch_port_needed(self):

\OpenStack\nova-2014.1\nova\virt\hyperv\networkutilsv2.py

class NetworkUtilsV2(networkutils.NetworkUtils):

    def __init__(self):

    def get_external_vswitch(self, vswitch_name):

    def create_vswitch_port(self, vswitch_path, port_name):

    def vswitch_port_needed(self):

\OpenStack\nova-2014.1\nova\virt\hyperv\pathutils.py

class PathUtils(object):

    def open(self, path, mode):

    def exists(self, path):

    def makedirs(self, path):

    def remove(self, path):

    def rename(self, src, dest):

    def copyfile(self, src, dest):

    def copy(self, src, dest):

    def rmtree(self, path):

    def get_instances_dir(self, remote_server=None):

    def _check_create_dir(self, path):

    def _check_remove_dir(self, path):

    def _get_instances_sub_dir(self, dir_name, remote_server=None, create_dir=True, remove_dir=False):

    def get_instance_migr_revert_dir(self, instance_name, create_dir=False, remove_dir=False):

    def get_instance_dir(self, instance_name, remote_server=None, create_dir=True, remove_dir=False):

    def _lookup_vhd_path(self, instance_name, vhd_path_func):

    def lookup_root_vhd_path(self, instance_name):

    def lookup_ephemeral_vhd_path(self, instance_name):

    def get_root_vhd_path(self, instance_name, format_ext):

    def get_ephemeral_vhd_path(self, instance_name, format_ext):

    def get_base_vhd_dir(self):

    def get_export_dir(self, instance_name):

\OpenStack\nova-2014.1\nova\virt\hyperv\rdpconsoleops.py

class RDPConsoleOps(object):

    def __init__(self):

    def get_rdp_console(self, instance):

\OpenStack\nova-2014.1\nova\virt\hyperv\rdpconsoleutils.py

class RDPConsoleUtils(object):

    def get_rdp_console_port(self):

\OpenStack\nova-2014.1\nova\virt\hyperv\rdpconsoleutilsv2.py

class RDPConsoleUtilsV2(rdpconsoleutils.RDPConsoleUtils):

    def __init__(self):

    def get_rdp_console_port(self):

\OpenStack\nova-2014.1\nova\virt\hyperv\snapshotops.py

class SnapshotOps(object):

    def __init__(self):

    def _save_glance_image(self, context, name, image_vhd_path):

    def snapshot(self, context, instance, name, update_task_state):

\OpenStack\nova-2014.1\nova\virt\hyperv\utilsfactory.py

def _get_class(v1_class, v2_class, force_v1_flag):

def get_vmutils(host='.'):

def get_vhdutils():

def get_networkutils():

def get_hostutils():

def get_pathutils():

def get_volumeutils():

def get_livemigrationutils():

def get_rdpconsoleutils():

\OpenStack\nova-2014.1\nova\virt\hyperv\vhdutils.py

class VHDUtils(object):

    def __init__(self):

    def validate_vhd(self, vhd_path):

    def create_dynamic_vhd(self, path, max_internal_size, format):

    def create_differencing_vhd(self, path, parent_path):

    def reconnect_parent_vhd(self, child_vhd_path, parent_vhd_path):

    def merge_vhd(self, src_vhd_path, dest_vhd_path):

    def _get_resize_method(self):

    def resize_vhd(self, vhd_path, new_max_size, is_file_max_size=True):

    def get_internal_vhd_size_by_file_size(self, vhd_path, new_vhd_file_size):

    def _get_vhd_dynamic_blk_size(self, vhd_path):

    def get_vhd_parent_path(self, vhd_path):

    def get_vhd_info(self, vhd_path):

    def get_vhd_format(self, path):

    def get_best_supported_vhd_format(self):

\OpenStack\nova-2014.1\nova\virt\hyperv\vhdutilsv2.py

class VHDUtilsV2(vhdutils.VHDUtils):

    def __init__(self):

    def create_dynamic_vhd(self, path, max_internal_size, format):

    def create_differencing_vhd(self, path, parent_path):

    def _create_vhd(self, vhd_type, format, path, max_internal_size=None, parent_path=None):

    def reconnect_parent_vhd(self, child_vhd_path, parent_vhd_path):

    def _get_resize_method(self):

    def get_internal_vhd_size_by_file_size(self, vhd_path, new_vhd_file_size):

    def _get_vhdx_current_header_offset(self, vhdx_file):

    def _get_vhdx_log_size(self, vhdx_file):

    def _get_vhdx_metadata_size_and_offset(self, vhdx_file):

    def _get_vhdx_block_size(self, vhdx_file):

    def _get_vhd_info_xml(self, image_man_svc, vhd_path):

    def get_vhd_info(self, vhd_path):

    def get_best_supported_vhd_format(self):

\OpenStack\nova-2014.1\nova\virt\hyperv\vif.py

class HyperVBaseVIFDriver(object):

    def plug(self, instance, vif):

    def unplug(self, instance, vif):

class HyperVNeutronVIFDriver(HyperVBaseVIFDriver):

    def plug(self, instance, vif):

    def unplug(self, instance, vif):

class HyperVNovaNetworkVIFDriver(HyperVBaseVIFDriver):

    def __init__(self):

    def plug(self, instance, vif):

    def unplug(self, instance, vif):

\OpenStack\nova-2014.1\nova\virt\hyperv\vmops.py

def check_admin_permissions(function):

 def wrapper(self, *args, **kwds):

class VMOps(object):

    def __init__(self):

    def _load_vif_driver_class(self):

    def list_instances(self):

    def get_info(self, instance):

    def _create_root_vhd(self, context, instance):

    def create_ephemeral_vhd(self, instance):

    def spawn(self, context, instance, image_meta, injected_files, admin_password, network_info, block_device_info=None):

    def create_instance(self, instance, network_info, block_device_info, root_vhd_path, eph_vhd_path):

    def _create_config_drive(self, instance, injected_files, admin_password):

    def _disconnect_volumes(self, volume_drives):

    def _delete_disk_files(self, instance_name):

    def destroy(self, instance, network_info=None, block_device_info=None, destroy_disks=True):

    def reboot(self, instance, network_info, reboot_type):

    def pause(self, instance):

    def unpause(self, instance):

    def suspend(self, instance):

    def resume(self, instance):

    def power_off(self, instance):

    def power_on(self, instance):

    def _set_vm_state(self, vm_name, req_state):

\OpenStack\nova-2014.1\nova\virt\hyperv\vmutils.py

class HyperVException(exception.NovaException):

    def __init__(self, message=None):

class VHDResizeException(HyperVException):

    def __init__(self, message=None):

class HyperVAuthorizationException(HyperVException):

    def __init__(self, message=None):

OpenStack Index

Previous

Next