@

Home 

OpenStack Study: nova

OpenStack Index

Previous

Next

def reverts_task_state(function):

 def decorated_function(self, context, *args, **kwargs):

def wrap_instance_fault(function):

 def decorated_function(self, context, *args, **kwargs):

def wrap_instance_event(function):

 def decorated_function(self, context, *args, **kwargs):

def delete_image_on_error(function):

 def decorated_function(self, context, image_id, instance, *args, **kwargs):

def object_compat(function):

 def decorated_function(self, context, *args, **kwargs):

def aggregate_object_compat(function):

 def decorated_function(self, context, *args, **kwargs):

def _get_image_meta(context, image_ref):

class InstanceEvents(object):

    def __init__(self):

    def _lock_name(instance):

    def prepare_for_instance_event(self, instance, event_name):

        def _create_or_get_event():

    def pop_instance_event(self, instance, event):

        def _pop_event():

    def clear_events_for_instance(self, instance):

        def _clear_events():

class ComputeVirtAPI(virtapi.VirtAPI):

    def __init__(self, compute):

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

    def wait_for_instance_event(self, instance, event_names, deadline=300, error_callback=None):

class ComputeManager(manager.Manager):

    def __init__(self, compute_driver=None, *args, **kwargs):

    def _get_resource_tracker(self, nodename):

    def _instance_update(self, context, instance_uuid, **kwargs):

    def _set_instance_error_state(self, context, instance_uuid):

    def _set_instance_obj_error_state(self, context, instance):

    def _get_instances_on_driver(self, context, filters=None):

    def _destroy_evacuated_instances(self, context):

    def _is_instance_storage_shared(self, context, instance):

    def _complete_partial_deletion(self, context, instance):

    def _complete_deletion(self, context, instance, bdms, quotas, system_meta):

    def _init_instance(self, context, instance):

    def _retry_reboot(self, context, instance):

    def handle_lifecycle_event(self, event):

    def handle_events(self, event):

    def init_virt_events(self):

    def init_host(self):

    def cleanup_host(self):

    def pre_start_hook(self):

    def _get_power_state(self, context, instance):

    def get_console_topic(self, context):

    def get_console_pool_info(self, context, console_type):

    def refresh_security_group_rules(self, context, security_group_id):

    def refresh_security_group_members(self, context, security_group_id):

    def refresh_instance_security_rules(self, context, instance):

        def _sync_refresh():

    def refresh_provider_fw_rules(self, context):

    def _get_instance_nw_info(self, context, instance, use_slave=False):

    def _await_block_device_map_created(self, context, vol_id, max_tries=180, wait_between=1):

    def _decode_files(self, injected_files):

        def _decode(f):

    def _run_instance(self, context, request_spec, filter_properties, requested_networks, injected_files, admin_password, is_first_time, node, instance, legacy_bdm_in_spec):

        def notify(status, msg="", fault=None, **kwargs):

    def _prebuild_instance(self, context, instance):

    def _validate_instance_group_policy(self, context, instance, filter_properties):

        def _do_validation(context, instance, group_uuid):

    def _build_instance(self, context, request_spec, filter_properties, requested_networks, injected_files, admin_password, is_first_time, node, instance, image_meta, legacy_bdm_in_spec):

    def _log_original_error(self, exc_info, instance_uuid):

    def _reschedule_or_error(self, context, instance, exc_info, requested_networks, admin_password, injected_files, is_first_time, request_spec, filter_properties, bdms=None, legacy_bdm_in_spec=True):

    def _reschedule(self, context, request_spec, filter_properties, instance_uuid, scheduler_method, method_args, task_state, exc_info=None):

    def _check_instance_build_time(self, context):

    def _check_instance_exists(self, context, instance):

    def _start_building(self, context, instance):

    def _allocate_network_async(self, context, instance, requested_networks, macs, security_groups, is_vpn, dhcp_options):

    def _build_networks_for_instance(self, context, instance, requested_networks, security_groups):

    def _allocate_network(self, context, instance, requested_networks, macs, security_groups, dhcp_options):

    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 _default_block_device_names(self, context, instance, image_meta, block_devices):

        def _is_mapping(bdm):

    def _prep_block_device(self, context, instance, bdms):

    def _spawn(self, context, instance, image_meta, network_info, block_device_info, injected_files, admin_password, set_access_ip=False):

        def _set_access_ip_values():

    def _notify_about_instance_usage(self, context, instance, event_suffix, network_info=None, system_metadata=None, extra_usage_info=None, fault=None):

    def _deallocate_network(self, context, instance, requested_networks=None):

    def _get_instance_volume_block_device_info(self, context, instance, refresh_conn_info=False, bdms=None):

    def build_and_run_instance(self, context, instance, image, request_spec, filter_properties, admin_password=None, injected_files=None, requested_networks=None, security_groups=None, block_device_mapping=None, node=None, limits=None):

        def do_build_and_run_instance(context, instance, image, request_spec, filter_properties, admin_password, injected_files, requested_networks, security_groups, block_device_mapping, node=None, limits=None):

    def _build_and_run_instance(self, context, instance, image, injected_files, admin_password, requested_networks, security_groups, block_device_mapping, node, limits):

    def _build_resources(self, context, instance, requested_networks, security_groups, image, block_device_mapping):

    def _cleanup_allocated_networks(self, context, instance, requested_networks):

    def _cleanup_build_resources(self, context, instance, block_device_mapping):

    def run_instance(self, context, instance, request_spec, filter_properties, requested_networks, injected_files, admin_password, is_first_time, node, legacy_bdm_in_spec):

        def do_run_instance():

    def _try_deallocate_network(self, context, instance, requested_networks=None):

    def _shutdown_instance(self, context, instance, bdms, requested_networks=None, notify=True):

    def _cleanup_volumes(self, context, instance_uuid, bdms):

    def _delete_instance(self, context, instance, bdms, reservations=None):

    def terminate_instance(self, context, instance, bdms, reservations):

        def do_terminate_instance(instance, bdms):

    def stop_instance(self, context, instance):

    def _power_on(self, context, instance):

    def start_instance(self, context, instance):

    def soft_delete_instance(self, context, instance, reservations):

    def restore_instance(self, context, instance):

    def _rebuild_default_impl(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 rebuild_instance(self, context, instance, orig_image_ref, image_ref, injected_files, new_pass, orig_sys_metadata, bdms, recreate, on_shared_storage, preserve_ephemeral=False):

    def _handle_bad_volumes_detached(self, context, instance, bad_devices, block_device_info):

    def reboot_instance(self, context, instance, block_device_info, reboot_type):

        def bad_volumes_callback(bad_devices):

    def backup_instance(self, context, image_id, instance, backup_type, rotation):

    def snapshot_instance(self, context, image_id, instance):

    def _snapshot_instance(self, context, image_id, instance, expected_task_state):

    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 _rotate_backups(self, context, instance, backup_type, rotation):

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

    def inject_file(self, context, path, file_contents, instance):

    def _get_rescue_image(self, context, instance):

    def rescue_instance(self, context, instance, rescue_password):

    def unrescue_instance(self, context, instance):

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

    def _cleanup_stored_instance_types(self, migration, instance, restore_old=False):

    def confirm_resize(self, context, instance, reservations, migration):

        def do_confirm_resize(context, instance, migration_id):

    def _confirm_resize(self, context, instance, reservations=None, migration=None):

    def revert_resize(self, context, instance, migration, reservations):

    def finish_revert_resize(self, context, instance, reservations, migration):

    def _quota_commit(self, context, reservations, project_id=None, user_id=None):

    def _quota_rollback(self, context, reservations, project_id=None, user_id=None):

    def _prep_resize(self, context, image, instance, instance_type, reservations, request_spec, filter_properties, node):

    def prep_resize(self, context, image, instance, instance_type, reservations, request_spec, filter_properties, node):

    def _reschedule_resize_or_reraise(self, context, image, instance, exc_info, instance_type, reservations, request_spec, filter_properties):

    def resize_instance(self, context, instance, image, reservations, migration, instance_type):

    def _terminate_volume_connections(self, context, instance, bdms):

    def _finish_resize(self, context, instance, migration, disk_info, image):

    def finish_resize(self, context, disk_info, image, instance, reservations, migration):

    def add_fixed_ip_to_instance(self, context, network_id, instance):

    def remove_fixed_ip_from_instance(self, context, address, instance):

    def pause_instance(self, context, instance):

    def unpause_instance(self, context, instance):

    def host_power_action(self, context, action):

    def host_maintenance_mode(self, context, host, mode):

    def set_host_enabled(self, context, enabled):

    def get_host_uptime(self, context):

    def get_diagnostics(self, context, instance):

    def suspend_instance(self, context, instance):

    def resume_instance(self, context, instance):

    def shelve_instance(self, context, instance, image_id):

        def update_task_state(task_state, expected_state=task_states.SHELVING):

    def shelve_offload_instance(self, context, instance):

    def unshelve_instance(self, context, instance, image, filter_properties=None, node=None):

        def do_unshelve_instance():

    def _unshelve_instance_key_scrub(self, instance):

    def _unshelve_instance_key_restore(self, instance, keys):

    def _unshelve_instance(self, context, instance, image, filter_properties, node):

    def reset_network(self, context, instance):

    def _inject_network_info(self, context, instance):

    def inject_network_info(self, context, instance):

    def get_console_output(self, context, instance, tail_length):

    def _tail_log(self, log, length):

    def get_vnc_console(self, context, console_type, instance):

    def get_spice_console(self, context, console_type, instance):

    def get_rdp_console(self, context, console_type, instance):

    def validate_console_port(self, ctxt, instance, port, console_type):

    def reserve_block_device_name(self, context, instance, device, volume_id, disk_bus=None, device_type=None):

        def do_reserve():

    def attach_volume(self, context, volume_id, mountpoint, instance, bdm=None):

    def _attach_volume(self, context, instance, bdm):

    def _detach_volume(self, context, instance, bdm):

    def detach_volume(self, context, volume_id, instance):

    def _init_volume_connection(self, context, new_volume_id, old_volume_id, connector, instance, bdm):

    def _swap_volume(self, context, instance, bdm, connector, old_volume_id, new_volume_id):

    def swap_volume(self, context, old_volume_id, new_volume_id, instance):

    def remove_volume_connection(self, context, volume_id, instance):

    def attach_interface(self, context, instance, network_id, port_id, requested_ip):

    def detach_interface(self, context, instance, port_id):

    def _get_compute_info(self, context, host):

    def check_instance_shared_storage(self, ctxt, instance, data):

    def check_can_live_migrate_destination(self, ctxt, instance, block_migration, disk_over_commit):

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

    def pre_live_migration(self, context, instance, block_migration, disk, migrate_data):

    def live_migration(self, context, dest, instance, block_migration, migrate_data):

    def _post_live_migration(self, ctxt, instance, dest, block_migration=False, migrate_data=None):

    def post_live_migration_at_destination(self, context, instance, block_migration):

    def _rollback_live_migration(self, context, instance, dest, block_migration, migrate_data=None):

    def rollback_live_migration_at_destination(self, context, instance):

    def _heal_instance_info_cache(self, context):

    def _poll_rebooting_instances(self, context):

    def _poll_rescued_instances(self, context):

    def _poll_unconfirmed_resizes(self, context):

        def _set_migration_to_error(migration, reason, **kwargs):

    def _poll_shelved_instances(self, context):

    def _instance_usage_audit(self, context):

    def _poll_bandwidth_usage(self, context):

    def _get_host_volume_bdms(self, context):

    def _update_volume_usage_cache(self, context, vol_usages):

    def _poll_volume_usage(self, context, start_time=None):

    def _sync_power_states(self, context):

    def _sync_instance_power_state(self, context, db_instance, vm_power_state, use_slave=False):

    def _reclaim_queued_deletes(self, context):

    def update_available_resource(self, context):

    def _get_compute_nodes_in_db(self, context):

    def _cleanup_running_deleted_instances(self, context):

    def _running_deleted_instances(self, context):

    def _deleted_old_enough(self, instance, timeout):

    def _error_out_instance_on_exception(self, context, instance_uuid, reservations=None, instance_state=vm_states.ACTIVE):

    def add_aggregate_host(self, context, aggregate, host, slave_info):

    def remove_aggregate_host(self, context, host, slave_info, aggregate):

    def _process_instance_event(self, instance, event):

    def external_instance_event(self, context, instances, events):

    def _run_image_cache_manager_pass(self, context):

    def _run_pending_deletes(self, context):

\OpenStack\nova-2014.1\nova\compute\monitors\cpu_monitor.py

class _CPUMonitorBase(monitors.ResourceMonitorBase):

    def _get_cpu_frequency(self, **kwargs):

    def _get_cpu_user_time(self, **kwargs):

    def _get_cpu_kernel_time(self, **kwargs):

    def _get_cpu_idle_time(self, **kwargs):

    def _get_cpu_iowait_time(self, **kwargs):

    def _get_cpu_user_percent(self, **kwargs):

    def _get_cpu_kernel_percent(self, **kwargs):

    def _get_cpu_idle_percent(self, **kwargs):

    def _get_cpu_iowait_percent(self, **kwargs):

    def _get_cpu_percent(self, **kwargs):

\OpenStack\nova-2014.1\nova\compute\monitors\virt\cpu_monitor.py

class ComputeDriverCPUMonitor(monitor._CPUMonitorBase):

    def __init__(self, parent):

    def _get_cpu_frequency(self, **kwargs):

    def _get_cpu_user_time(self, **kwargs):

    def _get_cpu_kernel_time(self, **kwargs):

    def _get_cpu_idle_time(self, **kwargs):

    def _get_cpu_iowait_time(self, **kwargs):

    def _get_cpu_user_percent(self, **kwargs):

    def _get_cpu_kernel_percent(self, **kwargs):

    def _get_cpu_idle_percent(self, **kwargs):

    def _get_cpu_iowait_percent(self, **kwargs):

    def _get_cpu_percent(self, **kwargs):

    def _update_data(self, **kwargs):

\OpenStack\nova-2014.1\nova\compute\monitors\virt\__init__.py

\OpenStack\nova-2014.1\nova\compute\monitors\__init__.py

class ResourceMonitorMeta(type):

    def __init__(cls, names, bases, dict_):

class ResourceMonitorBase(object):

    def __init__(self, parent):

    def add_timestamp(arg, func):

        def wrapper(cls, **kwargs):

    def _update_data(self):

    def get_metric_names(self):

    def get_metrics(self, **kwargs):

    def _populate(self, metric_name, metric_value, timestamp=None):

class ResourceMonitorHandler(loadables.BaseLoader):

    def __init__(self):

    def choose_monitors(self, manager):

def all_monitors():

\OpenStack\nova-2014.1\nova\compute\power_state.py

\OpenStack\nova-2014.1\nova\compute\resource_tracker.py

class ResourceTracker(object):

    def __init__(self, host, driver, nodename):

    def instance_claim(self, context, instance_ref, limits=None):

    def resize_claim(self, context, instance, instance_type, limits=None):

    def _create_migration(self, context, instance, instance_type):

    def _set_instance_host_and_node(self, context, instance_ref):

    def abort_instance_claim(self, instance):

    def drop_resize_claim(self, instance, instance_type=None, prefix='new_'):

    def update_usage(self, context, instance):

    def disabled(self):

    def _get_host_metrics(self, context, nodename):

    def update_available_resource(self, context):

    def _sync_compute_node(self, context, resources):

    def _create(self, context, values):

    def _get_service(self, context):

    def _report_hypervisor_resource_view(self, resources):

    def _report_final_resource_view(self, resources):

    def _update(self, context, values):

    def _update_usage(self, resources, usage, sign=1):

    def _update_usage_from_migration(self, context, instance, resources, migration):

    def _update_usage_from_migrations(self, context, resources, migrations):

    def _update_usage_from_instance(self, resources, instance):

    def _update_usage_from_instances(self, resources, instances):

    def _find_orphaned_instances(self):

    def _update_usage_from_orphans(self, resources, orphans):

    def _verify_resources(self, resources):

    def _instance_in_resize_state(self, instance):

    def _get_instance_type(self, context, instance, prefix, instance_type_id=None):

\OpenStack\nova-2014.1\nova\compute\rpcapi.py

def _compute_host(host, instance):

class ComputeAPI(object):

    def __init__(self):

    def get_client(self, target, version_cap, serializer):

    def _get_compat_version(self, current, havana_compat):

    def add_aggregate_host(self, ctxt, aggregate, host_param, host, slave_info=None):

    def add_fixed_ip_to_instance(self, ctxt, instance, network_id):

    def attach_interface(self, ctxt, instance, network_id, port_id, requested_ip):

    def attach_volume(self, ctxt, instance, volume_id, mountpoint, bdm=None):

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

    def check_can_live_migrate_destination(self, ctxt, instance, destination, block_migration, disk_over_commit):

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

    def check_instance_shared_storage(self, ctxt, instance, data):

    def confirm_resize(self, ctxt, instance, migration, host, reservations=None, cast=True):

    def detach_interface(self, ctxt, instance, port_id):

    def detach_volume(self, ctxt, instance, volume_id):

    def finish_resize(self, ctxt, instance, migration, image, disk_info, host, reservations=None):

    def finish_revert_resize(self, ctxt, instance, migration, host, reservations=None):

    def get_console_output(self, ctxt, instance, tail_length):

    def get_console_pool_info(self, ctxt, console_type, host):

    def get_console_topic(self, ctxt, host):

    def get_diagnostics(self, ctxt, instance):

    def get_vnc_console(self, ctxt, instance, console_type):

    def get_spice_console(self, ctxt, instance, console_type):

    def get_rdp_console(self, ctxt, instance, console_type):

    def validate_console_port(self, ctxt, instance, port, console_type):

    def host_maintenance_mode(self, ctxt, host_param, mode, host):

    def host_power_action(self, ctxt, action, host):

    def inject_network_info(self, ctxt, instance):

    def live_migration(self, ctxt, instance, dest, block_migration, host, migrate_data=None):

    def pause_instance(self, ctxt, instance):

    def post_live_migration_at_destination(self, ctxt, instance, block_migration, host):

    def pre_live_migration(self, ctxt, instance, block_migration, disk, host, migrate_data=None):

    def prep_resize(self, ctxt, image, instance, instance_type, host, reservations=None, request_spec=None, filter_properties=None, node=None):

    def reboot_instance(self, ctxt, instance, block_device_info, reboot_type):

    def rebuild_instance(self, ctxt, instance, new_pass, injected_files, image_ref, orig_image_ref, orig_sys_metadata, bdms, recreate=False, on_shared_storage=False, host=None, preserve_ephemeral=False, kwargs=None):

    def refresh_provider_fw_rules(self, ctxt, host):

    def remove_aggregate_host(self, ctxt, aggregate, host_param, host, slave_info=None):

    def remove_fixed_ip_from_instance(self, ctxt, instance, address):

    def remove_volume_connection(self, ctxt, instance, volume_id, host):

    def rescue_instance(self, ctxt, instance, rescue_password):

    def reset_network(self, ctxt, instance):

    def resize_instance(self, ctxt, instance, migration, image, instance_type, reservations=None):

    def resume_instance(self, ctxt, instance):

    def revert_resize(self, ctxt, instance, migration, host, reservations=None):

    def rollback_live_migration_at_destination(self, ctxt, instance, host):

    def run_instance(self, ctxt, instance, host, request_spec, filter_properties, requested_networks, injected_files, admin_password, is_first_time, node=None, legacy_bdm_in_spec=True):

    def set_admin_password(self, ctxt, instance, new_pass):

    def set_host_enabled(self, ctxt, enabled, host):

    def swap_volume(self, ctxt, instance, old_volume_id, new_volume_id):

    def get_host_uptime(self, ctxt, host):

    def reserve_block_device_name(self, ctxt, instance, device, volume_id, disk_bus=None, device_type=None):

    def backup_instance(self, ctxt, instance, image_id, backup_type, rotation):

    def snapshot_instance(self, ctxt, instance, image_id):

    def start_instance(self, ctxt, instance):

    def stop_instance(self, ctxt, instance, do_cast=True):

    def suspend_instance(self, ctxt, instance):

    def terminate_instance(self, ctxt, instance, bdms, reservations=None):

    def unpause_instance(self, ctxt, instance):

    def unrescue_instance(self, ctxt, instance):

    def soft_delete_instance(self, ctxt, instance, reservations=None):

    def restore_instance(self, ctxt, instance):

    def shelve_instance(self, ctxt, instance, image_id=None):

    def shelve_offload_instance(self, ctxt, instance):

    def unshelve_instance(self, ctxt, instance, host, image=None, filter_properties=None, node=None):

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

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

    def external_instance_event(self, ctxt, instances, events):

class SecurityGroupAPI(object):

    def __init__(self):

    def _get_compat_version(self, current, havana_compat):

    def refresh_security_group_rules(self, ctxt, security_group_id, host):

    def refresh_security_group_members(self, ctxt, security_group_id, host):

    def refresh_instance_security_rules(self, ctxt, host, instance):

\OpenStack\nova-2014.1\nova\compute\stats.py

class Stats(dict):

    def __init__(self):

    def clear(self):

    def io_workload(self):

        def _get(state, state_type):

    def calculate_workload(self):

    def num_instances(self):

    def num_instances_for_project(self, project_id):

    def num_os_type(self, os_type):

    def num_vcpus_used(self):

    def update_stats_for_instance(self, instance):

    def update_stats_for_migration(self, instance_type, sign=1):

    def _decrement(self, key):

    def _increment(self, key):

    def _extract_state_from_instance(self, instance):

\OpenStack\nova-2014.1\nova\compute\task_states.py

\OpenStack\nova-2014.1\nova\compute\utils.py

def exception_to_dict(fault):

def _get_fault_details(exc_info, error_code):

def add_instance_fault_from_exc(context, conductor, instance, fault, exc_info=None):

def pack_action_start(context, instance_uuid, action_name):

def pack_action_finish(context, instance_uuid):

def pack_action_event_start(context, instance_uuid, event_name):

def pack_action_event_finish(context, instance_uuid, event_name, exc_val=None, exc_tb=None):

def get_device_name_for_instance(context, instance, bdms, device):

def default_device_names_for_instance(instance, root_device_name, *block_device_lists):

def get_next_device_name(instance, device_name_list, root_device_name=None, device=None):

def _get_unused_letter(used_letters):

def get_image_metadata(context, image_service, image_id, instance):

def notify_usage_exists(notifier, context, instance_ref, current_period=False, ignore_missing_network_data=True, system_metadata=None, extra_usage_info=None):

def notify_about_instance_usage(notifier, context, instance, event_suffix, network_info=None, system_metadata=None, extra_usage_info=None, fault=None):

def notify_about_aggregate_update(context, event_suffix, aggregate_payload):

def notify_about_host_update(context, event_suffix, host_payload):

def get_nw_info_for_instance(instance):

def has_audit_been_run(context, conductor, host, timestamp=None):

def start_instance_usage_audit(context, conductor, begin, end, host, num_instances):

def finish_instance_usage_audit(context, conductor, begin, end, host, errors, message):

def usage_volume_info(vol_usage):

 def null_safe_str(s):

def get_reboot_type(task_state, current_power_state):

class EventReporter(object):

    def __init__(self, context, conductor, event_name, *instance_uuids):

    def __enter__(self):

    def __exit__(self, exc_type, exc_val, exc_tb):

\OpenStack\nova-2014.1\nova\compute\vm_mode.py

def get_from_instance(instance):

def name(mode):

\OpenStack\nova-2014.1\nova\compute\vm_states.py

\OpenStack\nova-2014.1\nova\compute\__init__.py

def _get_compute_api_class_name():

def API(*args, **kwargs):

def HostAPI(*args, **kwargs):

def InstanceActionAPI(*args, **kwargs):

\OpenStack\nova-2014.1\nova\conductor\api.py

class LocalAPI(object):

    def __init__(self):

    def wait_until_ready(self, context, *args, **kwargs):

    def instance_update(self, context, instance_uuid, **updates):

    def instance_get_by_uuid(self, context, instance_uuid, columns_to_join=None):

    def instance_destroy(self, context, instance):

    def instance_get_all_by_host(self, context, host, columns_to_join=None):

    def instance_get_all_by_host_and_node(self, context, host, node):

    def instance_get_all_by_filters(self, context, filters, sort_key='created_at', sort_dir='desc', columns_to_join=None, use_slave=False):

    def instance_get_active_by_window_joined(self, context, begin, end=None, project_id=None, host=None):

    def instance_info_cache_delete(self, context, instance):

    def instance_fault_create(self, context, values):

    def migration_get_in_progress_by_host_and_node(self, context, host, node):

    def aggregate_host_add(self, context, aggregate, host):

    def aggregate_host_delete(self, context, aggregate, host):

    def aggregate_metadata_get_by_host(self, context, host, key='availability_zone'):

    def bw_usage_get(self, context, uuid, start_period, mac):

    def bw_usage_update(self, context, uuid, mac, start_period, bw_in, bw_out, last_ctr_in, last_ctr_out, last_refreshed=None, update_cells=True):

    def provider_fw_rule_get_all(self, context):

    def agent_build_get_by_triple(self, context, hypervisor, os, architecture):

    def block_device_mapping_create(self, context, values):

    def block_device_mapping_update(self, context, bdm_id, values):

    def block_device_mapping_update_or_create(self, context, values):

    def block_device_mapping_get_all_by_instance(self, context, instance, legacy=True):

    def vol_get_usage_by_time(self, context, start_time):

    def vol_usage_update(self, context, vol_id, rd_req, rd_bytes, wr_req, wr_bytes, instance, last_refreshed=None, update_totals=False):

    def service_get_all(self, context):

    def service_get_all_by_topic(self, context, topic):

    def service_get_all_by_host(self, context, host):

    def service_get_by_host_and_topic(self, context, host, topic):

    def service_get_by_compute_host(self, context, host):

    def service_get_by_args(self, context, host, binary):

    def action_event_start(self, context, values):

    def action_event_finish(self, context, values):

    def service_create(self, context, values):

    def service_destroy(self, context, service_id):

    def compute_node_create(self, context, values):

    def compute_node_update(self, context, node, values, prune_stats=False):

    def compute_node_delete(self, context, node):

    def service_update(self, context, service, values):

    def task_log_get(self, context, task_name, begin, end, host, state=None):

    def task_log_begin_task(self, context, task_name, begin, end, host, task_items=None, message=None):

    def task_log_end_task(self, context, task_name, begin, end, host, errors, message=None):

    def notify_usage_exists(self, context, instance, current_period=False, ignore_missing_network_data=True, system_metadata=None, extra_usage_info=None):

    def security_groups_trigger_handler(self, context, event, *args):

    def security_groups_trigger_members_refresh(self, context, group_ids):

    def network_migrate_instance_start(self, context, instance, migration):

    def network_migrate_instance_finish(self, context, instance, migration):

    def quota_commit(self, context, reservations, project_id=None, user_id=None):

    def quota_rollback(self, context, reservations, project_id=None, user_id=None):

    def get_ec2_ids(self, context, instance):

    def compute_unrescue(self, context, instance):

    def object_backport(self, context, objinst, target_version):

class LocalComputeTaskAPI(object):

    def __init__(self):

    def resize_instance(self, context, instance, extra_instance_updates, scheduler_hint, flavor, reservations):

    def live_migrate_instance(self, context, instance, host_name, block_migration, disk_over_commit):

    def build_instances(self, context, instances, image, filter_properties, admin_password, injected_files, requested_networks, security_groups, block_device_mapping, legacy_bdm=True):

    def unshelve_instance(self, context, instance):

class API(LocalAPI):

    def __init__(self):

    def wait_until_ready(self, context, early_timeout=10, early_attempts=10):

    def instance_update(self, context, instance_uuid, **updates):

class ComputeTaskAPI(object):

    def __init__(self):

    def resize_instance(self, context, instance, extra_instance_updates, scheduler_hint, flavor, reservations):

    def live_migrate_instance(self, context, instance, host_name, block_migration, disk_over_commit):

    def build_instances(self, context, instances, image, filter_properties, admin_password, injected_files, requested_networks, security_groups, block_device_mapping, legacy_bdm=True):

    def unshelve_instance(self, context, instance):

\OpenStack\nova-2014.1\nova\conductor\manager.py

class ConductorManager(manager.Manager):

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

    def network_api(self):

    def compute_api(self):

    def ping(self, context, arg):

    def instance_update(self, context, instance_uuid, updates, service=None):

    def instance_get(self, context, instance_id):

    def instance_get_by_uuid(self, context, instance_uuid, columns_to_join=None):

    def instance_get_all(self, context):

    def instance_get_all_by_host(self, context, host, node=None, columns_to_join=None):

    def migration_get(self, context, migration_id):

    def migration_get_unconfirmed_by_dest_compute(self, context, confirm_window, dest_compute):

    def migration_get_in_progress_by_host_and_node(self, context, host, node):

    def migration_create(self, context, instance, values):

    def migration_update(self, context, migration, status):

    def aggregate_host_add(self, context, aggregate, host):

    def aggregate_host_delete(self, context, aggregate, host):

    def aggregate_get(self, context, aggregate_id):

    def aggregate_get_by_host(self, context, host, key=None):

    def aggregate_metadata_add(self, context, aggregate, metadata, set_delete=False):

    def aggregate_metadata_delete(self, context, aggregate, key):

    def aggregate_metadata_get_by_host(self, context, host, key='availability_zone'):

    def bw_usage_update(self, context, uuid, mac, start_period, bw_in=None, bw_out=None, last_ctr_in=None, last_ctr_out=None, last_refreshed=None, update_cells=True):

    def get_backdoor_port(self, context):

    def security_group_get_by_instance(self, context, instance):

    def security_group_rule_get_by_security_group(self, context, secgroup):

    def provider_fw_rule_get_all(self, context):

    def agent_build_get_by_triple(self, context, hypervisor, os, architecture):

    def block_device_mapping_update_or_create(self, context, values, create=None):

    def block_device_mapping_get_all_by_instance(self, context, instance, legacy=True):

    def block_device_mapping_destroy(self, context, bdms=None, instance=None, volume_id=None, device_name=None):

    def instance_get_all_by_filters(self, context, filters, sort_key, sort_dir, columns_to_join=None, use_slave=False):

    def instance_get_all_hung_in_rebooting(self, context, timeout):

    def instance_get_active_by_window(self, context, begin, end=None, project_id=None, host=None):

    def instance_get_active_by_window_joined(self, context, begin, end=None, project_id=None, host=None):

    def instance_destroy(self, context, instance):

    def instance_info_cache_delete(self, context, instance):

    def instance_info_cache_update(self, context, instance, values):

    def instance_type_get(self, context, instance_type_id):

    def instance_fault_create(self, context, values):

    def vol_get_usage_by_time(self, context, start_time):

    def vol_usage_update(self, context, vol_id, rd_req, rd_bytes, wr_req, wr_bytes, instance, last_refreshed=None, update_totals=False):

    def service_get_all_by(self, context, topic=None, host=None, binary=None):

    def action_event_start(self, context, values):

    def action_event_finish(self, context, values):

    def service_create(self, context, values):

    def service_destroy(self, context, service_id):

    def compute_node_create(self, context, values):

    def compute_node_update(self, context, node, values, prune_stats=False):

    def compute_node_delete(self, context, node):

    def service_update(self, context, service, values):

    def task_log_get(self, context, task_name, begin, end, host, state=None):

    def task_log_begin_task(self, context, task_name, begin, end, host, task_items=None, message=None):

    def task_log_end_task(self, context, task_name, begin, end, host, errors, message=None):

    def notify_usage_exists(self, context, instance, current_period=False, ignore_missing_network_data=True, system_metadata=None, extra_usage_info=None):

    def security_groups_trigger_handler(self, context, event, args):

    def security_groups_trigger_members_refresh(self, context, group_ids):

    def network_migrate_instance_start(self, context, instance, migration):

    def network_migrate_instance_finish(self, context, instance, migration):

    def quota_commit(self, context, reservations, project_id=None, user_id=None):

    def quota_rollback(self, context, reservations, project_id=None, user_id=None):

    def get_ec2_ids(self, context, instance):

    def compute_stop(self, context, instance, do_cast=True):

    def compute_confirm_resize(self, context, instance, migration_ref):

    def compute_unrescue(self, context, instance):

    def _object_dispatch(self, target, method, context, args, kwargs):

    def object_class_action(self, context, objname, objmethod, objver, args, kwargs):

    def object_action(self, context, objinst, objmethod, args, kwargs):

    def compute_reboot(self, context, instance, reboot_type):

    def object_backport(self, context, objinst, target_version):

class ComputeTaskManager(base.Base):

    def __init__(self):

    def migrate_server(self, context, instance, scheduler_hint, live, rebuild, flavor, block_migration, disk_over_commit, reservations=None):

    def _cold_migrate(self, context, instance, flavor, filter_properties, reservations):

    def _set_vm_state_and_notify(self, context, method, updates, ex, request_spec):

    def _live_migrate(self, context, instance, scheduler_hint, block_migration, disk_over_commit):

    def build_instances(self, context, instances, image, filter_properties, admin_password, injected_files, requested_networks, security_groups, block_device_mapping, legacy_bdm=True):

    def _get_image(self, context, image_id):

    def _delete_image(self, context, image_id):

    def _schedule_instances(self, context, image, filter_properties, *instances):

    def unshelve_instance(self, context, instance):

class _ConductorManagerV2Proxy(object):

    def __init__(self, manager):

    def instance_update(self, context, instance_uuid, updates, service):

    def instance_get_by_uuid(self, context, instance_uuid, columns_to_join):

    def migration_get_in_progress_by_host_and_node(self, context, host, node):

    def aggregate_host_add(self, context, aggregate, host):

    def aggregate_host_delete(self, context, aggregate, host):

    def aggregate_metadata_get_by_host(self, context, host, key):

    def bw_usage_update(self, context, uuid, mac, start_period, bw_in, bw_out, last_ctr_in, last_ctr_out, last_refreshed, update_cells):

    def provider_fw_rule_get_all(self, context):

    def agent_build_get_by_triple(self, context, hypervisor, os, architecture):

    def block_device_mapping_update_or_create(self, context, values, create):

    def block_device_mapping_get_all_by_instance(self, context, instance, legacy):

    def instance_get_all_by_filters(self, context, filters, sort_key, sort_dir, columns_to_join, use_slave):

    def instance_get_active_by_window_joined(self, context, begin, end, project_id, host):

    def instance_destroy(self, context, instance):

    def instance_info_cache_delete(self, context, instance):

    def vol_get_usage_by_time(self, context, start_time):

    def vol_usage_update(self, context, vol_id, rd_req, rd_bytes, wr_req, wr_bytes, instance, last_refreshed, update_totals):

    def service_get_all_by(self, context, topic, host, binary):

    def instance_get_all_by_host(self, context, host, node, columns_to_join):

    def instance_fault_create(self, context, values):

    def action_event_start(self, context, values):

    def action_event_finish(self, context, values):

    def service_create(self, context, values):

    def service_destroy(self, context, service_id):

    def compute_node_create(self, context, values):

    def compute_node_update(self, context, node, values):

    def compute_node_delete(self, context, node):

    def service_update(self, context, service, values):

    def task_log_get(self, context, task_name, begin, end, host, state):

    def task_log_begin_task(self, context, task_name, begin, end, host, task_items, message):

    def task_log_end_task(self, context, task_name, begin, end, host, errors, message):

    def notify_usage_exists(self, context, instance, current_period, ignore_missing_network_data, system_metadata, extra_usage_info):

    def security_groups_trigger_handler(self, context, event, args):

    def security_groups_trigger_members_refresh(self, context, group_ids):

    def network_migrate_instance_start(self, context, instance, migration):

    def network_migrate_instance_finish(self, context, instance, migration):

    def quota_commit(self, context, reservations, project_id, user_id):

    def quota_rollback(self, context, reservations, project_id, user_id):

    def get_ec2_ids(self, context, instance):

    def compute_unrescue(self, context, instance):

    def object_class_action(self, context, objname, objmethod, objver, args, kwargs):

    def object_action(self, context, objinst, objmethod, args, kwargs):

    def object_backport(self, context, objinst, target_version):

\OpenStack\nova-2014.1\nova\conductor\rpcapi.py

class ConductorAPI(object):

    def __init__(self):

    def instance_update(self, context, instance_uuid, updates, service=None):

    def instance_get_by_uuid(self, context, instance_uuid, columns_to_join=None):

    def migration_get_in_progress_by_host_and_node(self, context, host, node):

    def aggregate_host_add(self, context, aggregate, host):

    def aggregate_host_delete(self, context, aggregate, host):

    def aggregate_metadata_get_by_host(self, context, host, key):

    def bw_usage_update(self, context, uuid, mac, start_period, bw_in=None, bw_out=None, last_ctr_in=None, last_ctr_out=None, last_refreshed=None, update_cells=True):

    def provider_fw_rule_get_all(self, context):

    def agent_build_get_by_triple(self, context, hypervisor, os, architecture):

    def block_device_mapping_update_or_create(self, context, values, create=None):

    def block_device_mapping_get_all_by_instance(self, context, instance, legacy=True):

    def instance_get_all_by_filters(self, context, filters, sort_key, sort_dir, columns_to_join=None, use_slave=False):

    def instance_get_active_by_window_joined(self, context, begin, end=None, project_id=None, host=None):

    def instance_destroy(self, context, instance):

    def instance_info_cache_delete(self, context, instance):

    def vol_get_usage_by_time(self, context, start_time):

    def vol_usage_update(self, context, vol_id, rd_req, rd_bytes, wr_req, wr_bytes, instance, last_refreshed=None, update_totals=False):

    def service_get_all_by(self, context, topic=None, host=None, binary=None):

    def instance_get_all_by_host(self, context, host, node=None, columns_to_join=None):

    def instance_fault_create(self, context, values):

    def action_event_start(self, context, values):

    def action_event_finish(self, context, values):

    def service_create(self, context, values):

    def service_destroy(self, context, service_id):

    def compute_node_create(self, context, values):

    def compute_node_update(self, context, node, values):

    def compute_node_delete(self, context, node):

    def service_update(self, context, service, values):

    def task_log_get(self, context, task_name, begin, end, host, state=None):

    def task_log_begin_task(self, context, task_name, begin, end, host, task_items=None, message=None):

    def task_log_end_task(self, context, task_name, begin, end, host, errors, message=None):

    def notify_usage_exists(self, context, instance, current_period=False, ignore_missing_network_data=True, system_metadata=None, extra_usage_info=None):

    def security_groups_trigger_handler(self, context, event, args):

    def security_groups_trigger_members_refresh(self, context, group_ids):

    def network_migrate_instance_start(self, context, instance, migration):

    def network_migrate_instance_finish(self, context, instance, migration):

    def quota_commit(self, context, reservations, project_id=None, user_id=None):

    def quota_rollback(self, context, reservations, project_id=None, user_id=None):

    def get_ec2_ids(self, context, instance):

    def compute_unrescue(self, context, instance):

    def object_class_action(self, context, objname, objmethod, objver, args, kwargs):

    def object_action(self, context, objinst, objmethod, args, kwargs):

    def object_backport(self, context, objinst, target_version):

class ComputeTaskAPI(object):

    def __init__(self):

    def migrate_server(self, context, instance, scheduler_hint, live, rebuild, flavor, block_migration, disk_over_commit, reservations=None):

    def build_instances(self, context, instances, image, filter_properties, admin_password, injected_files, requested_networks, security_groups, block_device_mapping, legacy_bdm=True):

    def unshelve_instance(self, context, instance):

\OpenStack\nova-2014.1\nova\conductor\tasks\live_migrate.py

class LiveMigrationTask(object):

    def __init__(self, context, instance, destination, block_migration, disk_over_commit):

    def execute(self):

    def rollback(self):

    def _check_instance_is_running(self):

    def _check_host_is_up(self, host):

    def _check_requested_destination(self):

    def _check_destination_is_not_source(self):

    def _check_destination_has_enough_memory(self):

    def _get_compute_info(self, host):

    def _check_compatible_with_source_hypervisor(self, destination):

    def _call_livem_checks_on_host(self, destination):

    def _find_destination(self):

    def _check_not_over_max_retries(self, attempted_hosts):

def execute(context, instance, destination, block_migration, disk_over_commit):

\OpenStack\nova-2014.1\nova\conductor\tasks\__init__.py

\OpenStack\nova-2014.1\nova\conductor\__init__.py

def API(*args, **kwargs):

def ComputeTaskAPI(*args, **kwargs):

\OpenStack\nova-2014.1\nova\config.py

def parse_args(argv, default_config_files=None):

\OpenStack\nova-2014.1\nova\console\api.py

class API(base.Base):

    def __init__(self, **kwargs):

    def get_consoles(self, context, instance_uuid):

    def get_console(self, context, instance_uuid, console_uuid):

    def delete_console(self, context, instance_uuid, console_uuid):

    def create_console(self, context, instance_uuid):

    def _get_console_topic(self, context, instance_host):

    def _get_instance(self, context, instance_uuid):

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

class FakeConsoleProxy(object):

    def console_type(self):

    def setup_console(self, context, console):

    def teardown_console(self, context, console):

    def init_host(self):

    def generate_password(self, length=8):

    def get_port(self, context):

    def fix_pool_password(self, password):

    def fix_console_password(self, password):

\OpenStack\nova-2014.1\nova\console\manager.py

class ConsoleProxyManager(manager.Manager):

    def __init__(self, console_driver=None, *args, **kwargs):

    def init_host(self):

    def add_console(self, context, instance_id):

    def remove_console(self, context, console_id):

    def _get_pool_for_instance_host(self, context, instance_host):

\OpenStack\nova-2014.1\nova\console\rpcapi.py

class ConsoleAPI(object):

    def __init__(self, topic=None, server=None):

    def _get_compat_version(self, current, havana_compat):

    def add_console(self, ctxt, instance_id):

    def remove_console(self, ctxt, console_id):

\OpenStack\nova-2014.1\nova\console\vmrc.py

class VMRCConsole(object):

    def __init__(self):

    def console_type(self):

    def get_port(self, context):

    def setup_console(self, context, console):

    def teardown_console(self, context, console):

    def init_host(self):

    def fix_pool_password(self, password):

    def generate_password(self, vim_session, pool, instance_name):

    def is_otp(self):

class VMRCSessionConsole(VMRCConsole):

    def __init__(self):

    def console_type(self):

    def generate_password(self, vim_session, pool, instance_name):

    def is_otp(self):

\OpenStack\nova-2014.1\nova\console\vmrc_manager.py

class ConsoleVMRCManager(manager.Manager):

    def __init__(self, console_driver=None, *args, **kwargs):

    def init_host(self):

    def _get_vim_session(self, pool):

    def _generate_console(self, context, pool, name, instance_id, instance):

    def add_console(self, context, instance_id, password=None, port=None, **kwargs):

    def remove_console(self, context, console_id, **_kwargs):

    def get_pool_for_instance_host(self, context, instance_host):

\OpenStack\nova-2014.1\nova\console\websocketproxy.py

class NovaWebSocketProxy(websockify.WebSocketProxy):

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

    def new_client(self):

\OpenStack\nova-2014.1\nova\console\xvp.py

class XVPConsoleProxy(object):

    def __init__(self):

    def console_type(self):

    def get_port(self, context):

    def setup_console(self, context, console):

    def teardown_console(self, context, console):

    def init_host(self):

    def fix_pool_password(self, password):

    def fix_console_password(self, password):

    def _rebuild_xvp_conf(self, context):

    def _write_conf(self, config):

    def _xvp_stop(self):

    def _xvp_start(self):

    def _xvp_restart(self):

    def _xvp_pid(self):

    def _xvp_check_running(self):

    def _xvp_encrypt(self, password, is_pool_password=False):

\OpenStack\nova-2014.1\nova\console\__init__.py

\OpenStack\nova-2014.1\nova\consoleauth\manager.py

class ConsoleAuthManager(manager.Manager):

    def __init__(self, scheduler_driver=None, *args, **kwargs):

    def _get_tokens_for_instance(self, instance_uuid):

    def authorize_console(self, context, token, console_type, host, port, internal_access_path, instance_uuid):

    def _validate_token(self, context, token):

    def check_token(self, context, token):

    def delete_tokens_for_instance(self, context, instance_uuid):

\OpenStack\nova-2014.1\nova\consoleauth\rpcapi.py

class ConsoleAuthAPI(object):

    def __init__(self):

    def authorize_console(self, ctxt, token, console_type, host, port, internal_access_path, instance_uuid):

    def check_token(self, ctxt, token):

    def delete_tokens_for_instance(self, ctxt, instance_uuid):

\OpenStack\nova-2014.1\nova\consoleauth\__init__.py

\OpenStack\nova-2014.1\nova\context.py

def generate_request_id():

class RequestContext(object):

    def __init__(self, user_id, project_id, is_admin=None, read_deleted="no", roles=None, remote_address=None, timestamp=None, request_id=None, auth_token=None, overwrite=True, quota_class=None, user_name=None, project_name=None, service_catalog=None, instance_lock_checked=False, **kwargs):

    def _get_read_deleted(self):

    def _set_read_deleted(self, read_deleted):

    def _del_read_deleted(self):

    def update_store(self):

    def to_dict(self):

    def from_dict(cls, values):

    def elevated(self, read_deleted=None, overwrite=False):

    def tenant(self):

    def user(self):

def get_admin_context(read_deleted="no"):

def is_user_context(context):

def require_admin_context(ctxt):

def require_context(ctxt):

def authorize_project_context(context, project_id):

def authorize_user_context(context, user_id):

def authorize_quota_class_context(context, class_name):

\OpenStack\nova-2014.1\nova\crypto.py

def ca_folder(project_id=None):

def ca_path(project_id=None):

def key_path(project_id=None):

def crl_path(project_id=None):

def fetch_ca(project_id=None):

def ensure_ca_filesystem():

def _generate_fingerprint(public_key_file):

def generate_fingerprint(public_key):

def generate_key_pair(bits=None):

def fetch_crl(project_id):

def decrypt_text(project_id, text):

def _to_sequence(*vals):

def convert_from_sshrsa_to_pkcs8(pubkey):

def ssh_encrypt_text(ssh_public_key, text):

def revoke_cert(project_id, file_name):

def revoke_certs_by_user(user_id):

def revoke_certs_by_project(project_id):

def revoke_certs_by_user_and_project(user_id, project_id):

def _project_cert_subject(project_id):

def _user_cert_subject(user_id, project_id):

def generate_x509_cert(user_id, project_id, bits=1024):

def _ensure_project_folder(project_id):

def generate_vpn_files(project_id):

def sign_csr(csr_text, project_id=None):

def _sign_csr(csr_text, ca_folder):

def compute_md5(fp):

\OpenStack\nova-2014.1\nova\db\api.py

def constraint(**conditions):

def equal_any(*values):

def not_equal(*values):

def service_destroy(context, service_id):

def service_get(context, service_id):

def service_get_by_host_and_topic(context, host, topic):

def service_get_all(context, disabled=None):

def service_get_all_by_topic(context, topic):

def service_get_all_by_host(context, host):

def service_get_by_compute_host(context, host):

def service_get_by_args(context, host, binary):

def service_create(context, values):

def service_update(context, service_id, values):

def compute_node_get(context, compute_id):

def compute_node_get_by_service_id(context, service_id):

def compute_node_get_all(context, no_date_fields=False):

def compute_node_search_by_hypervisor(context, hypervisor_match):

def compute_node_create(context, values):

def compute_node_update(context, compute_id, values):

def compute_node_delete(context, compute_id):

def compute_node_statistics(context):

def certificate_create(context, values):

def certificate_get_all_by_project(context, project_id):

def certificate_get_all_by_user(context, user_id):

def certificate_get_all_by_user_and_project(context, user_id, project_id):

def floating_ip_get(context, id):

def floating_ip_get_pools(context):

def floating_ip_allocate_address(context, project_id, pool, auto_assigned=False):

def floating_ip_bulk_create(context, ips):

def floating_ip_bulk_destroy(context, ips):

def floating_ip_create(context, values):

def floating_ip_deallocate(context, address):

def floating_ip_destroy(context, address):

def floating_ip_disassociate(context, address):

def floating_ip_fixed_ip_associate(context, floating_address, fixed_address, host):

def floating_ip_get_all(context):

def floating_ip_get_all_by_host(context, host):

def floating_ip_get_all_by_project(context, project_id):

def floating_ip_get_by_address(context, address):

def floating_ip_get_by_fixed_address(context, fixed_address):

def floating_ip_get_by_fixed_ip_id(context, fixed_ip_id):

def floating_ip_update(context, address, values):

def floating_ip_set_auto_assigned(context, address):

def dnsdomain_list(context):

def dnsdomain_get_all(context):

def dnsdomain_register_for_zone(context, fqdomain, zone):

def dnsdomain_register_for_project(context, fqdomain, project):

def dnsdomain_unregister(context, fqdomain):

def dnsdomain_get(context, fqdomain):

def migration_update(context, id, values):

def migration_create(context, values):

def migration_get(context, migration_id):

def migration_get_by_instance_and_status(context, instance_uuid, status):

def migration_get_unconfirmed_by_dest_compute(context, confirm_window, dest_compute, use_slave=False):

def migration_get_in_progress_by_host_and_node(context, host, node):

def migration_get_all_by_filters(context, filters):

def fixed_ip_associate(context, address, instance_uuid, network_id=None, reserved=False):

def fixed_ip_associate_pool(context, network_id, instance_uuid=None, host=None):

def fixed_ip_create(context, values):

def fixed_ip_bulk_create(context, ips):

def fixed_ip_disassociate(context, address):

def fixed_ip_disassociate_all_by_timeout(context, host, time):

def fixed_ip_get(context, id, get_network=False):

def fixed_ip_get_all(context):

def fixed_ip_get_by_address(context, address, columns_to_join=None):

def fixed_ip_get_by_address_detailed(context, address):

def fixed_ip_get_by_floating_address(context, floating_address):

def fixed_ip_get_by_instance(context, instance_uuid):

def fixed_ip_get_by_host(context, host):

def fixed_ip_get_by_network_host(context, network_uuid, host):

def fixed_ips_by_virtual_interface(context, vif_id):

def fixed_ip_update(context, address, values):

def virtual_interface_create(context, values):

def virtual_interface_get(context, vif_id):

def virtual_interface_get_by_address(context, address):

def virtual_interface_get_by_uuid(context, vif_uuid):

def virtual_interface_get_by_instance(context, instance_id, use_slave=False):

def virtual_interface_get_by_instance_and_network(context, instance_id, network_id):

def virtual_interface_delete_by_instance(context, instance_id):

def virtual_interface_get_all(context):

def instance_create(context, values):

def instance_destroy(context, instance_uuid, constraint=None, update_cells=True):

def instance_get_by_uuid(context, uuid, columns_to_join=None, use_slave=False):

def instance_get(context, instance_id, columns_to_join=None):

def instance_get_all(context, columns_to_join=None):

def instance_get_all_by_filters(context, filters, sort_key='created_at', sort_dir='desc', limit=None, marker=None, columns_to_join=None, use_slave=False):

def instance_get_active_by_window_joined(context, begin, end=None, project_id=None, host=None):

def instance_get_all_by_host(context, host, columns_to_join=None, use_slave=False):

def instance_get_all_by_host_and_node(context, host, node):

def instance_get_all_by_host_and_not_type(context, host, type_id=None):

def instance_get_floating_address(context, instance_id):

def instance_floating_address_get_all(context, instance_uuid):

def instance_get_all_hung_in_rebooting(context, reboot_window):

def instance_update(context, instance_uuid, values, update_cells=True):

def instance_update_and_get_original(context, instance_uuid, values, update_cells=True, columns_to_join=None):

def instance_add_security_group(context, instance_id, security_group_id):

def instance_remove_security_group(context, instance_id, security_group_id):

def instance_group_create(context, values, policies=None, metadata=None, members=None):

def instance_group_get(context, group_uuid):

def instance_group_update(context, group_uuid, values):

def instance_group_delete(context, group_uuid):

def instance_group_get_all(context):

def instance_group_get_all_by_project_id(context, project_id):

def instance_group_metadata_add(context, group_uuid, metadata, set_delete=False):

def instance_group_metadata_delete(context, group_uuid, key):

def instance_group_metadata_get(context, group_uuid):

def instance_group_members_add(context, group_uuid, members, set_delete=False):

def instance_group_member_delete(context, group_uuid, instance_id):

def instance_group_members_get(context, group_uuid):

def instance_group_policies_add(context, group_uuid, policies, set_delete=False):

def instance_group_policy_delete(context, group_uuid, policy):

def instance_group_policies_get(context, group_uuid):

def instance_info_cache_get(context, instance_uuid):

def instance_info_cache_update(context, instance_uuid, values):

def instance_info_cache_delete(context, instance_uuid):

def key_pair_create(context, values):

def key_pair_destroy(context, user_id, name):

OpenStack Index

Previous

Next