@

Home 

OpenStack Study: nova

OpenStack Index

Previous

Next

def validate_device_name(value):

def validate_and_default_volume_size(bdm):

def is_ephemeral(device_name):

def ephemeral_num(ephemeral_name):

def is_swap_or_ephemeral(device_name):

def new_format_is_swap(bdm):

def new_format_is_ephemeral(bdm):

def get_root_bdm(bdms):

def mappings_prepend_dev(mappings):

def strip_dev(device_name):

def prepend_dev(device_name):

def strip_prefix(device_name):

def instance_block_mapping(instance, bdms):

def match_device(device):

def volume_in_mapping(mount_device, block_device_info):

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

class BaseCellsDriver(object):

    def start_servers(self, msg_runner):

    def stop_servers(self):

    def send_message_to_cell(self, cell_state, message):

\OpenStack\nova-2014.1\nova\cells\filters\image_properties.py

class ImagePropertiesFilter(filters.BaseCellFilter):

    def filter_all(self, cells, filter_properties):

    def _matches_version(self, version, version_requires):

\OpenStack\nova-2014.1\nova\cells\filters\target_cell.py

class TargetCellFilter(filters.BaseCellFilter):

    def filter_all(self, cells, filter_properties):

\OpenStack\nova-2014.1\nova\cells\filters\__init__.py

class BaseCellFilter(filters.BaseFilter):

    def authorized(self, ctxt):

    def _filter_one(self, cell, filter_properties):

    def cell_passes(self, cell, filter_properties):

class CellFilterHandler(filters.BaseFilterHandler):

    def __init__(self):

def all_filters():

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

class CellsManager(manager.Manager):

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

    def post_start_hook(self):

    def _update_our_parents(self, ctxt):

    def _heal_instances(self, ctxt):

        def _next_instance():

    def _sync_instance(self, ctxt, instance):

    def schedule_run_instance(self, ctxt, host_sched_kwargs):

    def build_instances(self, ctxt, build_inst_kwargs):

    def get_cell_info_for_neighbors(self, _ctxt):

    def run_compute_api_method(self, ctxt, cell_name, method_info, call):

    def instance_update_at_top(self, ctxt, instance):

    def instance_destroy_at_top(self, ctxt, instance):

    def instance_delete_everywhere(self, ctxt, instance, delete_type):

    def instance_fault_create_at_top(self, ctxt, instance_fault):

    def bw_usage_update_at_top(self, ctxt, bw_update_info):

    def sync_instances(self, ctxt, project_id, updated_since, deleted):

    def service_get_all(self, ctxt, filters):

    def service_get_by_compute_host(self, ctxt, host_name):

    def get_host_uptime(self, ctxt, host_name):

    def service_update(self, ctxt, host_name, binary, params_to_update):

    def service_delete(self, ctxt, cell_service_id):

    def proxy_rpc_to_manager(self, ctxt, topic, rpc_message, call, timeout):

    def task_log_get_all(self, ctxt, task_name, period_beginning, period_ending, host=None, state=None):

    def compute_node_get(self, ctxt, compute_id):

    def compute_node_get_all(self, ctxt, hypervisor_match=None):

    def compute_node_stats(self, ctxt):

    def actions_get(self, ctxt, cell_name, instance_uuid):

    def action_get_by_request_id(self, ctxt, cell_name, instance_uuid, request_id):

    def action_events_get(self, ctxt, cell_name, action_id):

    def consoleauth_delete_tokens(self, ctxt, instance_uuid):

    def validate_console_port(self, ctxt, instance_uuid, console_port, console_type):

    def get_capacities(self, ctxt, cell_name):

    def bdm_update_or_create_at_top(self, ctxt, bdm, create=None):

    def bdm_destroy_at_top(self, ctxt, instance_uuid, device_name=None, volume_id=None):

    def get_migrations(self, ctxt, filters):

    def instance_update_from_api(self, ctxt, instance, expected_vm_state, expected_task_state, admin_state_reset):

    def start_instance(self, ctxt, instance):

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

    def cell_create(self, ctxt, values):

    def cell_update(self, ctxt, cell_name, values):

    def cell_delete(self, ctxt, cell_name):

    def cell_get(self, ctxt, cell_name):

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

    def pause_instance(self, ctxt, instance):

    def unpause_instance(self, ctxt, instance):

    def suspend_instance(self, ctxt, instance):

    def resume_instance(self, ctxt, instance):

    def terminate_instance(self, ctxt, instance):

    def soft_delete_instance(self, ctxt, instance):

    def resize_instance(self, ctxt, instance, flavor, extra_instance_updates):

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

    def revert_resize(self, ctxt, instance):

    def confirm_resize(self, ctxt, instance):

    def reset_network(self, ctxt, instance):

    def inject_network_info(self, ctxt, instance):

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

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

    def rebuild_instance(self, ctxt, instance, image_href, admin_password, files_to_inject, preserve_ephemeral, kwargs):

\OpenStack\nova-2014.1\nova\cells\messaging.py

def _reverse_path(path):

def _response_cell_name_from_path(routing_path, neighbor_only=False):

class _BaseMessage(object):

    def __init__(self, msg_runner, ctxt, method_name, method_kwargs, direction, need_response=False, fanout=False, uuid=None, routing_path=None, hop_count=0, max_hop_count=None, **kwargs):

    def __repr__(self):

    def _append_hop(self):

    def _process_locally(self):

    def _setup_response_queue(self):

    def _cleanup_response_queue(self):

    def _wait_for_json_responses(self, num_responses=1):

    def _send_json_responses(self, json_responses, neighbor_only=False, fanout=False):

    def _send_response(self, response, neighbor_only=False):

    def _send_response_from_exception(self, exc_info):

    def _to_dict(self):

    def to_json(self):

    def source_is_us(self):

    def process(self):

class _TargetedMessage(_BaseMessage):

    def __init__(self, msg_runner, ctxt, method_name, method_kwargs, direction, target_cell, **kwargs):

    def _get_next_hop(self):

    def process(self):

class _BroadcastMessage(_BaseMessage):

    def __init__(self, msg_runner, ctxt, method_name, method_kwargs, direction, run_locally=True, **kwargs):

    def _get_next_hops(self):

    def _send_to_cells(self, target_cells):

    def _send_json_responses(self, json_responses):

    def process(self):

class _ResponseMessage(_TargetedMessage):

    def __init__(self, msg_runner, ctxt, method_name, method_kwargs, direction, target_cell, response_uuid, **kwargs):

    def process(self):

class _BaseMessageMethods(base.Base):

    def __init__(self, msg_runner):

    def task_log_get_all(self, message, task_name, period_beginning, period_ending, host, state):

class _ResponseMessageMethods(_BaseMessageMethods):

    def parse_responses(self, message, orig_message, responses):

class _TargetedMessageMethods(_BaseMessageMethods):

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

    def schedule_run_instance(self, message, host_sched_kwargs):

    def build_instances(self, message, build_inst_kwargs):

    def run_compute_api_method(self, message, method_info):

    def update_capabilities(self, message, cell_name, capabilities):

    def update_capacities(self, message, cell_name, capacities):

    def announce_capabilities(self, message):

    def announce_capacities(self, message):

    def service_get_by_compute_host(self, message, host_name):

    def service_update(self, message, host_name, binary, params_to_update):

    def service_delete(self, message, service_id):

    def proxy_rpc_to_manager(self, message, host_name, rpc_message, topic, timeout):

    def compute_node_get(self, message, compute_id):

    def actions_get(self, message, instance_uuid):

    def action_get_by_request_id(self, message, instance_uuid, request_id):

    def action_events_get(self, message, action_id):

    def validate_console_port(self, message, instance_uuid, console_port, console_type):

    def get_migrations(self, message, filters):

    def instance_update_from_api(self, message, instance, expected_vm_state, expected_task_state, admin_state_reset):

    def _call_compute_api_with_obj(self, ctxt, instance, method, *args, **kwargs):

    def start_instance(self, message, instance):

    def stop_instance(self, message, instance):

    def reboot_instance(self, message, instance, reboot_type):

    def suspend_instance(self, message, instance):

    def resume_instance(self, message, instance):

    def get_host_uptime(self, message, host_name):

    def terminate_instance(self, message, instance):

    def soft_delete_instance(self, message, instance):

    def pause_instance(self, message, instance):

    def unpause_instance(self, message, instance):

    def resize_instance(self, message, instance, flavor, extra_instance_updates):

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

    def revert_resize(self, message, instance):

    def confirm_resize(self, message, instance):

    def reset_network(self, message, instance):

    def inject_network_info(self, message, instance):

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

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

    def rebuild_instance(self, message, instance, image_href, admin_password, files_to_inject, preserve_ephemeral, kwargs):

class _BroadcastMessageMethods(_BaseMessageMethods):

    def _at_the_top(self):

    def _apply_expected_states(self, instance_info):

    def instance_update_at_top(self, message, instance, **kwargs):

    def instance_destroy_at_top(self, message, instance, **kwargs):

    def instance_delete_everywhere(self, message, instance, delete_type, **kwargs):

    def instance_fault_create_at_top(self, message, instance_fault, **kwargs):

    def bw_usage_update_at_top(self, message, bw_update_info, **kwargs):

    def _sync_instance(self, ctxt, instance):

    def sync_instances(self, message, project_id, updated_since, deleted, **kwargs):

    def service_get_all(self, message, filters):

    def compute_node_get_all(self, message, hypervisor_match):

    def compute_node_stats(self, message):

    def consoleauth_delete_tokens(self, message, instance_uuid):

    def bdm_update_or_create_at_top(self, message, bdm, create):

    def bdm_destroy_at_top(self, message, instance_uuid, device_name, volume_id):

    def get_migrations(self, message, filters):

class MessageRunner(object):

    def __init__(self, state_manager):

    def _process_message_locally(self, message):

    def _put_response(self, response_uuid, response):

    def _setup_response_queue(self, message):

    def _cleanup_response_queue(self, message):

    def _create_response_message(self, ctxt, direction, target_cell, response_uuid, response_kwargs, **kwargs):

    def _get_migrations_for_cell(self, ctxt, cell_name, filters):

    def message_from_json(self, json_message):

    def ask_children_for_capabilities(self, ctxt):

    def ask_children_for_capacities(self, ctxt):

    def tell_parents_our_capabilities(self, ctxt):

    def tell_parents_our_capacities(self, ctxt):

    def schedule_run_instance(self, ctxt, target_cell, host_sched_kwargs):

    def build_instances(self, ctxt, target_cell, build_inst_kwargs):

    def run_compute_api_method(self, ctxt, cell_name, method_info, call):

    def instance_update_at_top(self, ctxt, instance):

    def instance_destroy_at_top(self, ctxt, instance):

    def instance_delete_everywhere(self, ctxt, instance, delete_type):

    def instance_fault_create_at_top(self, ctxt, instance_fault):

    def bw_usage_update_at_top(self, ctxt, bw_update_info):

    def sync_instances(self, ctxt, project_id, updated_since, deleted):

    def service_get_all(self, ctxt, filters=None):

    def service_get_by_compute_host(self, ctxt, cell_name, host_name):

    def get_host_uptime(self, ctxt, cell_name, host_name):

    def service_update(self, ctxt, cell_name, host_name, binary, params_to_update):

    def service_delete(self, ctxt, cell_name, service_id):

    def proxy_rpc_to_manager(self, ctxt, cell_name, host_name, topic, rpc_message, call, timeout):

    def task_log_get_all(self, ctxt, cell_name, task_name, period_beginning, period_ending, host=None, state=None):

    def compute_node_get_all(self, ctxt, hypervisor_match=None):

    def compute_node_stats(self, ctxt):

    def compute_node_get(self, ctxt, cell_name, compute_id):

    def actions_get(self, ctxt, cell_name, instance_uuid):

    def action_get_by_request_id(self, ctxt, cell_name, instance_uuid, request_id):

    def action_events_get(self, ctxt, cell_name, action_id):

    def consoleauth_delete_tokens(self, ctxt, instance_uuid):

    def validate_console_port(self, ctxt, cell_name, instance_uuid, console_port, console_type):

    def bdm_update_or_create_at_top(self, ctxt, bdm, create=None):

    def bdm_destroy_at_top(self, ctxt, instance_uuid, device_name=None, volume_id=None):

    def get_migrations(self, ctxt, cell_name, run_locally, filters):

    def _instance_action(self, ctxt, instance, method, extra_kwargs=None, need_response=False):

    def instance_update_from_api(self, ctxt, instance, expected_vm_state, expected_task_state, admin_state_reset):

    def start_instance(self, ctxt, instance):

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

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

    def suspend_instance(self, ctxt, instance):

    def resume_instance(self, ctxt, instance):

    def terminate_instance(self, ctxt, instance):

    def soft_delete_instance(self, ctxt, instance):

    def pause_instance(self, ctxt, instance):

    def unpause_instance(self, ctxt, instance):

    def resize_instance(self, ctxt, instance, flavor, extra_instance_updates):

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

    def revert_resize(self, ctxt, instance):

    def confirm_resize(self, ctxt, instance):

    def reset_network(self, ctxt, instance):

    def inject_network_info(self, ctxt, instance):

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

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

    def rebuild_instance(self, ctxt, instance, image_href, admin_password, files_to_inject, preserve_ephemeral, kwargs):

    def get_message_types():

class Response(object):

    def __init__(self, cell_name, value, failure):

    def to_json(self):

    def from_json(cls, json_message):

    def value_or_raise(self):

def serialize_remote_exception(failure_info, log_failure=True):

def deserialize_remote_exception(data, allowed_remote_exmods):

\OpenStack\nova-2014.1\nova\cells\opts.py

def get_cell_type():

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

class CellsAPI(object):

    def __init__(self):

    def cast_compute_api_method(self, ctxt, cell_name, method, *args, **kwargs):

    def call_compute_api_method(self, ctxt, cell_name, method, *args, **kwargs):

    def schedule_run_instance(self, ctxt, **kwargs):

    def build_instances(self, ctxt, **kwargs):

    def instance_update_at_top(self, ctxt, instance):

    def instance_destroy_at_top(self, ctxt, instance):

    def instance_delete_everywhere(self, ctxt, instance, delete_type):

    def instance_fault_create_at_top(self, ctxt, instance_fault):

    def bw_usage_update_at_top(self, ctxt, uuid, mac, start_period, bw_in, bw_out, last_ctr_in, last_ctr_out, last_refreshed=None):

    def instance_info_cache_update_at_top(self, ctxt, instance_info_cache):

    def get_cell_info_for_neighbors(self, ctxt):

    def sync_instances(self, ctxt, project_id=None, updated_since=None, deleted=False):

    def service_get_all(self, ctxt, filters=None):

    def service_get_by_compute_host(self, ctxt, host_name):

    def get_host_uptime(self, context, host_name):

    def service_update(self, ctxt, host_name, binary, params_to_update):

    def service_delete(self, ctxt, cell_service_id):

    def proxy_rpc_to_manager(self, ctxt, rpc_message, topic, call=False, timeout=None):

    def task_log_get_all(self, ctxt, task_name, period_beginning, period_ending, host=None, state=None):

    def compute_node_get(self, ctxt, compute_id):

    def compute_node_get_all(self, ctxt, hypervisor_match=None):

    def compute_node_stats(self, ctxt):

    def actions_get(self, ctxt, instance):

    def action_get_by_request_id(self, ctxt, instance, request_id):

    def action_events_get(self, ctxt, instance, action_id):

    def consoleauth_delete_tokens(self, ctxt, instance_uuid):

    def validate_console_port(self, ctxt, instance_uuid, console_port, console_type):

    def get_capacities(self, ctxt, cell_name=None):

    def bdm_update_or_create_at_top(self, ctxt, bdm, create=None):

    def bdm_destroy_at_top(self, ctxt, instance_uuid, device_name=None, volume_id=None):

    def get_migrations(self, ctxt, filters):

    def instance_update_from_api(self, ctxt, instance, expected_vm_state, expected_task_state, admin_state_reset):

    def start_instance(self, ctxt, instance):

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

    def cell_create(self, ctxt, values):

    def cell_update(self, ctxt, cell_name, values):

    def cell_delete(self, ctxt, cell_name):

    def cell_get(self, ctxt, cell_name):

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

    def pause_instance(self, ctxt, instance):

    def unpause_instance(self, ctxt, instance):

    def suspend_instance(self, ctxt, instance):

    def resume_instance(self, ctxt, instance):

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

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

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

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

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

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

    def reset_network(self, ctxt, instance):

    def inject_network_info(self, ctxt, instance):

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

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

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

\OpenStack\nova-2014.1\nova\cells\rpc_driver.py

class CellsRPCDriver(driver.BaseCellsDriver):

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

    def start_servers(self, msg_runner):

    def stop_servers(self):

    def send_message_to_cell(self, cell_state, message):

class InterCellRPCAPI(object):

    def __init__(self):

    def _get_client(self, next_hop, topic):

    def send_message_to_cell(self, cell_state, message):

class InterCellRPCDispatcher(object):

    def __init__(self, msg_runner):

    def process_message(self, _ctxt, message):

\OpenStack\nova-2014.1\nova\cells\scheduler.py

class CellsScheduler(base.Base):

    def __init__(self, msg_runner):

    def _create_instances_here(self, ctxt, instance_uuids, instance_properties, instance_type, image, security_groups, block_device_mapping):

    def _create_action_here(self, ctxt, instance_uuids):

    def _get_possible_cells(self):

    def _grab_target_cells(self, filter_properties):

    def _run_instance(self, message, target_cells, instance_uuids, host_sched_kwargs):

    def _build_instances(self, message, target_cells, instance_uuids, build_inst_kwargs):

    def build_instances(self, message, build_inst_kwargs):

    def run_instance(self, message, host_sched_kwargs):

    def _schedule_build_to_cells(self, message, instance_uuids, filter_properties, method, method_kwargs):

\OpenStack\nova-2014.1\nova\cells\state.py

class CellState(object):

    def __init__(self, cell_name, is_me=False):

    def update_db_info(self, cell_db_info):

    def update_capabilities(self, cell_metadata):

    def update_capacities(self, capacities):

    def get_cell_info(self):

    def send_message(self, message):

    def __repr__(self):

def sync_before(f):

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

def sync_after(f):

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

class CellStateManager(base.Base):

    def __new__(cls, cell_state_cls=None, cells_config=_unset):

    def __init__(self, cell_state_cls=None):

    def _refresh_cells_from_dict(self, db_cells_dict):

    def _time_to_sync(self):

    def _update_our_capacity(self, ctxt=None):

        def _get_compute_hosts():

        def _free_units(total, free, per_inst):

    def get_cell_info_for_neighbors(self):

    def get_my_state(self):

    def get_child_cells(self):

    def get_parent_cells(self):

    def get_parent_cell(self, cell_name):

    def get_child_cell(self, cell_name):

    def update_cell_capabilities(self, cell_name, capabilities):

    def update_cell_capacities(self, cell_name, capacities):

    def get_our_capabilities(self, include_children=True):

    def _add_to_dict(self, target, src):

    def get_our_capacities(self, include_children=True):

    def get_capacities(self, cell_name=None):

    def cell_get(self, ctxt, cell_name):

class CellStateManagerDB(CellStateManager):

    def _cell_data_sync(self, force=False):

    def cell_create(self, ctxt, values):

    def cell_update(self, ctxt, cell_name, values):

    def cell_delete(self, ctxt, cell_name):

class CellStateManagerFile(CellStateManager):

    def __init__(self, cell_state_cls, cells_config_path):

    def _cell_data_sync(self, force=False):

    def cell_create(self, ctxt, values):

    def cell_update(self, ctxt, cell_name, values):

    def cell_delete(self, ctxt, cell_name):

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

def get_instances_to_sync(context, updated_since=None, project_id=None, deleted=True, shuffle=False, uuids_only=False):

def cell_with_item(cell_name, item):

def split_cell_and_item(cell_and_item):

def _add_cell_to_service(service, cell_name):

def add_cell_to_compute_node(compute_node, cell_name):

def add_cell_to_service(service, cell_name):

def add_cell_to_task_log(task_log, cell_name):

\OpenStack\nova-2014.1\nova\cells\weights\mute_child.py

class MuteChildWeigher(weights.BaseCellWeigher):

    def weight_multiplier(self):

    def _weigh_object(self, cell, weight_properties):

\OpenStack\nova-2014.1\nova\cells\weights\ram_by_instance_type.py

class RamByInstanceTypeWeigher(weights.BaseCellWeigher):

    def weight_multiplier(self):

    def _weigh_object(self, cell, weight_properties):

\OpenStack\nova-2014.1\nova\cells\weights\weight_offset.py

class WeightOffsetWeigher(weights.BaseCellWeigher):

    def weight_multiplier(self):

    def _weigh_object(self, cell, weight_properties):

\OpenStack\nova-2014.1\nova\cells\weights\__init__.py

class WeightedCell(weights.WeighedObject):

    def __repr__(self):

class BaseCellWeigher(weights.BaseWeigher):

class CellWeightHandler(weights.BaseWeightHandler):

    def __init__(self):

def all_weighers():

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

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

class CertManager(manager.Manager):

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

    def init_host(self):

    def revoke_certs_by_user(self, context, user_id):

    def revoke_certs_by_project(self, context, project_id):

    def revoke_certs_by_user_and_project(self, context, user_id, project_id):

    def generate_x509_cert(self, context, user_id, project_id):

    def fetch_ca(self, context, project_id):

    def fetch_crl(self, context, project_id):

    def decrypt_text(self, context, project_id, text):

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

class CertAPI(object):

    def __init__(self):

    def _get_compat_version(self, current, havana_compat):

    def revoke_certs_by_user(self, ctxt, user_id):

    def revoke_certs_by_project(self, ctxt, project_id):

    def revoke_certs_by_user_and_project(self, ctxt, user_id, project_id):

    def generate_x509_cert(self, ctxt, user_id, project_id):

    def fetch_ca(self, ctxt, project_id):

    def fetch_crl(self, ctxt, project_id):

    def decrypt_text(self, ctxt, project_id, text):

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

\OpenStack\nova-2014.1\nova\cloudpipe\pipelib.py

def is_vpn_image(image_id):

def _load_boot_script():

class CloudPipe(object):

    def __init__(self):

    def get_encoded_zip(self, project_id):

    def launch_vpn_instance(self, context):

    def setup_security_group(self, context):

    def setup_key_pair(self, context):

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

\OpenStack\nova-2014.1\nova\cmd\all.py

def main():

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

def main():

\OpenStack\nova-2014.1\nova\cmd\api_ec2.py

def main():

\OpenStack\nova-2014.1\nova\cmd\api_metadata.py

def main():

\OpenStack\nova-2014.1\nova\cmd\api_os_compute.py

def main():

\OpenStack\nova-2014.1\nova\cmd\baremetal_deploy_helper.py

class BareMetalDeployException(Exception):

    def raise_exception(msg):

def deploy(address, port, iqn, lun, image_path, pxe_config_path, root_mb, swap_mb, ephemeral_mb, preserve_ephemeral=False):

class Worker(threading.Thread):

    def __init__(self):

    def run(self):

class BareMetalDeploy(object):

    def __init__(self):

    def __call__(self, environ, start_response):

    def post(self, environ, start_response):

def main():

\OpenStack\nova-2014.1\nova\cmd\baremetal_manage.py

def args(*args, **kwargs):

 def _decorator(func):

class BareMetalDbCommands(object):

    def __init__(self):

    def sync(self, version=None):

    def version(self):

def methods_of(obj):

def add_command_parsers(subparsers):

def main():

\OpenStack\nova-2014.1\nova\cmd\cells.py

def main():

\OpenStack\nova-2014.1\nova\cmd\cert.py

def main():

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

def block_db_access():

def main():

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

def main():

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

def main():

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

def main():

\OpenStack\nova-2014.1\nova\cmd\dhcpbridge.py

def add_lease(mac, ip_address):

def old_lease(mac, ip_address):

def del_lease(mac, ip_address):

def init_leases(network_id):

def add_action_parsers(subparsers):

def main():

\OpenStack\nova-2014.1\nova\cmd\manage.py

def args(*args, **kwargs):

 def _decorator(func):

def param2id(object_id):

class VpnCommands(object):

    def change(self, project_id, ip, port):

class ShellCommands(object):

    def bpython(self):

    def ipython(self):

    def python(self):

    def run(self, shell=None):

    def script(self, path):

def _db_error(caught_exception):

class ProjectCommands(object):

    def quota(self, project_id, user_id=None, key=None, value=None):

    def scrub(self, project_id):

class FixedIpCommands(object):

    def list(self, host=None):

    def reserve(self, address):

    def unreserve(self, address):

    def _set_reserved(self, address, reserved):

class FloatingIpCommands(object):

    def address_to_hosts(addresses):

    def create(self, ip_range, pool=None, interface=None):

    def delete(self, ip_range):

    def list(self, host=None):

class NetworkCommands(object):

    def create(self, label=None, cidr=None, num_networks=None, network_size=None, multi_host=None, vlan_start=None, vpn_start=None, cidr_v6=None, gateway=None, gateway_v6=None, bridge=None, bridge_interface=None, dns1=None, dns2=None, project_id=None, priority=None, uuid=None, fixed_cidr=None):

    def list(self):

    def delete(self, fixed_range=None, uuid=None):

    def modify(self, fixed_range, project=None, host=None, dis_project=None, dis_host=None):

class VmCommands(object):

    def list(self, host=None):

class ServiceCommands(object):

    def list(self, host=None, service=None):

    def enable(self, host, service):

    def disable(self, host, service):

    def _show_host_resources(self, context, host):

    def describe_resource(self, host):

class HostCommands(object):

    def list(self, zone=None):

class DbCommands(object):

    def __init__(self):

    def sync(self, version=None):

    def version(self):

    def archive_deleted_rows(self, max_rows):

class FlavorCommands(object):

    def _print_flavors(self, val):

    def create(self, name, memory, vcpus, root_gb, ephemeral_gb=0, flavorid=None, swap=0, rxtx_factor=1.0, is_public=True):

    def delete(self, name):

    def list(self, name=None):

    def set_key(self, name, key, value=None):

    def unset_key(self, name, key):

class AgentBuildCommands(object):

    def create(self, os, architecture, version, url, md5hash, hypervisor='xen'):

    def delete(self, os, architecture, hypervisor='xen'):

    def list(self, hypervisor=None):

    def modify(self, os, architecture, version, url, md5hash, hypervisor='xen'):

class GetLogCommands(object):

    def errors(self):

    def syslog(self, num_entries=10):

class CellCommands(object):

    def create(self, name, cell_type='child', username=None, password=None, hostname=None, port=None, virtual_host=None, woffset=None, wscale=None):

    def delete(self, cell_name):

    def list(self):

def methods_of(obj):

def add_command_parsers(subparsers):

def main():

\OpenStack\nova-2014.1\nova\cmd\network.py

def block_db_access():

def main():

\OpenStack\nova-2014.1\nova\cmd\novnc.py

\OpenStack\nova-2014.1\nova\cmd\novncproxy.py

def main():

\OpenStack\nova-2014.1\nova\cmd\objectstore.py

def main():

\OpenStack\nova-2014.1\nova\cmd\scheduler.py

def main():

\OpenStack\nova-2014.1\nova\cmd\spicehtml5proxy.py

def main():

\OpenStack\nova-2014.1\nova\cmd\xvpvncproxy.py

def main():

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

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

def check_instance_state(vm_state=None, task_state=(None,), must_have_launched=True):

 def outer(f):

def check_instance_host(function):

 def wrapped(self, context, instance, *args, **kwargs):

def check_instance_lock(function):

 def inner(self, context, instance, *args, **kwargs):

def policy_decorator(scope):

 def outer(func):

def check_policy(context, action, target, scope='compute'):

def check_instance_cell(fn):

 def _wrapped(self, context, instance, *args, **kwargs):

def _diff_dict(orig, new):

class API(base.Base):

    def __init__(self, image_service=None, network_api=None, volume_api=None, security_group_api=None, **kwargs):

    def compute_task_api(self):

    def cell_type(self):

    def _cell_read_only(self, cell_name):

    def _validate_cell(self, instance, method):

    def _record_action_start(self, context, instance, action):

    def _check_injected_file_quota(self, context, injected_files):

    def _check_num_instances_quota(self, context, instance_type, min_count, max_count):

    def _check_metadata_properties_quota(self, context, metadata=None):

    def _check_requested_secgroups(self, context, secgroups):

    def _check_requested_networks(self, context, requested_networks, max_count):

    def _handle_kernel_and_ramdisk(context, kernel_id, ramdisk_id, image):

    def _handle_availability_zone(context, availability_zone):

    def _ensure_auto_disk_config_is_valid(self, auto_disk_config_img, auto_disk_config, image):

    def _inherit_properties_from_image(self, image, auto_disk_config):

    def _apply_instance_name_template(self, context, instance, index):

    def _check_config_drive(self, config_drive):

    def _check_requested_image(self, context, image_id, image, instance_type):

    def _check_and_transform_bdm(self, base_options, image_meta, min_count, max_count, block_device_mapping, legacy_bdm):

    def _get_image(self, context, image_href):

    def _checks_for_create_and_rebuild(self, context, image_id, image, instance_type, metadata, files_to_inject):

    def _validate_and_build_base_options(self, context, instance_type, boot_meta, image_href, image_id, kernel_id, ramdisk_id, display_name, display_description, key_name, key_data, security_groups, availability_zone, forced_host, user_data, metadata, injected_files, access_ip_v4, access_ip_v6, requested_networks, config_drive, block_device_mapping, auto_disk_config, reservation_id, max_count):

    def _build_filter_properties(self, context, scheduler_hints, forced_host, forced_node, instance_type):

    def _provision_instances(self, context, instance_type, min_count, max_count, base_options, boot_meta, security_groups, block_device_mapping):

    def _get_bdm_image_metadata(self, context, block_device_mapping, legacy_bdm=True):

    def _update_instance_group_by_name(context, instance_uuids, group_name):

    def _update_instance_group(context, instances, scheduler_hints):

    def _create_instance(self, context, instance_type, image_href, kernel_id, ramdisk_id, min_count, max_count, display_name, display_description, key_name, key_data, security_groups, availability_zone, user_data, metadata, injected_files, admin_password, access_ip_v4, access_ip_v6, requested_networks, config_drive, block_device_mapping, auto_disk_config, reservation_id=None, scheduler_hints=None, legacy_bdm=True):

    def _volume_size(instance_type, bdm):

    def _prepare_image_mapping(self, instance_type, instance_uuid, mappings):

    def _update_block_device_mapping(self, elevated_context, instance_type, instance_uuid, block_device_mapping):

    def _validate_bdm(self, context, instance, instance_type, all_mappings):

        def _subsequent_list(l):

    def _populate_instance_for_bdm(self, context, instance, instance_type, image, block_device_mapping):

    def _populate_instance_shutdown_terminate(self, instance, image, block_device_mapping):

    def _populate_instance_names(self, instance, num_instances):

    def _default_display_name(self, instance_uuid):

    def _populate_instance_for_create(self, instance, image, index, security_groups, instance_type):

    def create_db_entry_for_new_instance(self, context, instance_type, image, instance, security_group, block_device_mapping, num_instances, index):

    def _check_create_policies(self, context, availability_zone, requested_networks, block_device_mapping):

    def _check_multiple_instances_neutron_ports(self, requested_networks):

    def create(self, context, instance_type, image_href, kernel_id=None, ramdisk_id=None, min_count=None, max_count=None, display_name=None, display_description=None, key_name=None, key_data=None, security_group=None, availability_zone=None, user_data=None, metadata=None, injected_files=None, admin_password=None, block_device_mapping=None, access_ip_v4=None, access_ip_v6=None, requested_networks=None, config_drive=None, auto_disk_config=None, scheduler_hints=None, legacy_bdm=True):

    def trigger_provider_fw_rules_refresh(self, context):

    def update(self, context, instance, **kwargs):

    def _update(self, context, instance, **kwargs):

    def _check_auto_disk_config(self, instance=None, image=None, **extra_instance_updates):

    def _delete(self, context, instance, delete_type, cb, **instance_attrs):

    def _confirm_resize_on_deleting(self, context, instance):

    def _create_reservations(self, context, old_instance, new_instance_type_id, project_id, user_id):

    def _local_delete(self, context, instance, bdms, delete_type, cb):

    def _do_delete(self, context, instance, bdms, reservations=None, local=False):

    def _do_soft_delete(self, context, instance, bdms, reservations=None, local=False):

    def soft_delete(self, context, instance):

    def _delete_instance(self, context, instance):

    def delete(self, context, instance):

    def restore(self, context, instance):

    def force_delete(self, context, instance):

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

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

    def start(self, context, instance):

    def get(self, context, instance_id, want_objects=False, expected_attrs=None):

    def get_all(self, context, search_opts=None, sort_key='created_at', sort_dir='desc', limit=None, marker=None, want_objects=False, expected_attrs=None):

        def _remap_flavor_filter(flavor_id):

        def _remap_fixed_ip_filter(fixed_ip):

    def _get_instances_by_filters(self, context, filters, sort_key, sort_dir, limit=None, marker=None, expected_attrs=None):

    def backup(self, context, instance, name, backup_type, rotation, extra_properties=None):

    def snapshot(self, context, instance, name, extra_properties=None):

    def _create_image(self, context, instance, name, image_type, extra_properties=None):

    def snapshot_volume_backed(self, context, instance, image_meta, name, extra_properties=None):

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

    def rebuild(self, context, instance, image_href, admin_password, files_to_inject=None, **kwargs):

        def _reset_image_metadata():

    def revert_resize(self, context, instance):

    def confirm_resize(self, context, instance, migration=None):

    def _resize_quota_delta(context, new_flavor, old_flavor, sense, compare):

        def _quota_delta(resource):

    def _upsize_quota_delta(context, new_flavor, old_flavor):

    def _reverse_upsize_quota_delta(context, migration_ref):

    def _downsize_quota_delta(context, instance):

    def _reserve_quota_delta(context, deltas, project_id=None):

    def _resize_cells_support(context, quotas, instance, current_instance_type, new_instance_type):

    def resize(self, context, instance, flavor_id=None, **extra_instance_updates):

    def shelve(self, context, instance):

    def shelve_offload(self, context, instance):

    def unshelve(self, context, instance):

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

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

    def pause(self, context, instance):

    def unpause(self, context, instance):

    def get_diagnostics(self, context, instance):

    def suspend(self, context, instance):

    def resume(self, context, instance):

    def rescue(self, context, instance, rescue_password=None):

    def unrescue(self, context, instance):

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

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

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

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

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

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

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

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

    def lock(self, context, instance):

    def unlock(self, context, instance):

    def get_lock(self, context, instance):

    def reset_network(self, context, instance):

    def inject_network_info(self, context, instance):

    def _attach_volume(self, context, instance, volume_id, device, disk_bus, device_type):

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

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

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

    def swap_volume(self, context, instance, old_volume, new_volume):

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

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

    def get_instance_metadata(self, context, instance):

    def get_all_instance_metadata(self, context, search_filts):

    def get_all_system_metadata(self, context, search_filts):

    def _get_all_instance_metadata(self, context, search_filts, metadata_type):

        def _match_any(pattern_list, string):

        def _filter_metadata(instance, search_filt, input_metadata):

    def delete_instance_metadata(self, context, instance, key):

    def update_instance_metadata(self, context, instance, metadata, delete=False):

    def get_instance_faults(self, context, instances):

    def is_volume_backed_instance(self, context, instance, bdms=None):

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

    def evacuate(self, context, instance, host, on_shared_storage, admin_password=None):

    def get_migrations(self, context, filters):

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

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

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

class HostAPI(base.Base):

    def __init__(self, rpcapi=None):

    def _assert_host_exists(self, context, host_name, must_be_up=False):

    def set_host_enabled(self, context, host_name, enabled):

    def get_host_uptime(self, context, host_name):

    def host_power_action(self, context, host_name, action):

    def set_host_maintenance(self, context, host_name, mode):

    def service_get_all(self, context, filters=None, set_zones=False):

    def service_get_by_compute_host(self, context, host_name):

    def service_update(self, context, host_name, binary, params_to_update):

    def service_delete(self, context, service_id):

    def instance_get_all_by_host(self, context, host_name):

    def task_log_get_all(self, context, task_name, period_beginning, period_ending, host=None, state=None):

    def compute_node_get(self, context, compute_id):

    def compute_node_get_all(self, context):

    def compute_node_search_by_hypervisor(self, context, hypervisor_match):

    def compute_node_statistics(self, context):

class InstanceActionAPI(base.Base):

    def actions_get(self, context, instance):

    def action_get_by_request_id(self, context, instance, request_id):

    def action_events_get(self, context, instance, action_id):

class AggregateAPI(base.Base):

    def __init__(self, **kwargs):

    def create_aggregate(self, context, aggregate_name, availability_zone):

    def get_aggregate(self, context, aggregate_id):

    def get_aggregate_list(self, context):

    def is_safe_to_update_az(self, context, aggregate, metadata, action_name):

    def update_aggregate(self, context, aggregate_id, values):

    def update_aggregate_metadata(self, context, aggregate_id, metadata):

    def delete_aggregate(self, context, aggregate_id):

    def _check_az_for_host(self, aggregate_meta, host_az, aggregate_id):

    def _update_az_cache_for_host(self, context, host_name, aggregate_meta):

    def add_host_to_aggregate(self, context, aggregate_id, host_name):

    def remove_host_from_aggregate(self, context, aggregate_id, host_name):

    def _reformat_aggregate_info(self, aggregate):

class KeypairAPI(base.Base):

    def _notify(self, context, event_suffix, keypair_name):

    def _validate_new_key_pair(self, context, user_id, key_name):

    def import_key_pair(self, context, user_id, key_name, public_key):

    def create_key_pair(self, context, user_id, key_name):

    def delete_key_pair(self, context, user_id, key_name):

    def get_key_pairs(self, context, user_id):

    def get_key_pair(self, context, user_id, key_name):

class SecurityGroupAPI(base.Base, security_group_base.SecurityGroupBase):

    def __init__(self, **kwargs):

    def validate_property(self, value, property, allowed):

    def ensure_default(self, context):

    def create_security_group(self, context, name, description):

    def update_security_group(self, context, security_group, name, description):

    def get(self, context, name=None, id=None, map_exception=False):

    def list(self, context, names=None, ids=None, project=None, search_opts=None):

    def destroy(self, context, security_group):

    def is_associated_with_server(self, security_group, instance_uuid):

    def add_to_instance(self, context, instance, security_group_name):

    def remove_from_instance(self, context, instance, security_group_name):

    def get_rule(self, context, id):

    def add_rules(self, context, id, name, vals):

    def remove_rules(self, context, security_group, rule_ids):

    def remove_default_rules(self, context, rule_ids):

    def add_default_rules(self, context, vals):

    def default_rule_exists(self, context, values):

    def get_all_default_rules(self, context):

    def get_default_rule(self, context, id):

    def validate_id(self, id):

    def trigger_rules_refresh(self, context, id):

    def trigger_members_refresh(self, context, group_ids):

    def get_instance_security_groups(self, context, instance_uuid, detailed=False):

    def populate_security_groups(self, instance, security_groups):

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

class ComputeRPCAPIRedirect(object):

    def __init__(self, cells_rpcapi):

    def __getattr__(self, key):

        def _noop_rpc_wrapper(*args, **kwargs):

class SchedulerRPCAPIRedirect(object):

    def __init__(self, cells_rpcapi_obj):

    def __getattr__(self, key):

        def _noop_rpc_wrapper(*args, **kwargs):

class ConductorTaskRPCAPIRedirect(object):

    def __init__(self, cells_rpcapi_obj):

    def __getattr__(self, key):

        def _noop_rpc_wrapper(*args, **kwargs):

class RPCClientCellsProxy(object):

    def __init__(self, target, version_cap):

    def prepare(self, **kwargs):

    def _check_version_cap(self, version):

    def _make_msg(self, method, **kwargs):

    def _get_topic(self):

    def can_send_version(self, version):

    def cast(self, ctxt, method, **kwargs):

    def call(self, ctxt, method, **kwargs):

class ComputeRPCProxyAPI(compute_rpcapi.ComputeAPI):

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

class ComputeCellsAPI(compute_api.API):

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

    def _cast_to_cells(self, context, instance, method, *args, **kwargs):

    def _call_to_cells(self, context, instance, method, *args, **kwargs):

    def _check_requested_networks(self, context, requested_networks, max_count):

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

    def update(self, context, instance, **kwargs):

    def soft_delete(self, context, instance):

    def delete(self, context, instance):

    def _handle_cell_delete(self, context, instance, method_name):

    def restore(self, context, instance):

    def force_delete(self, context, instance):

    def evacuate(self, context, instance, *args, **kwargs):

    def add_fixed_ip(self, context, instance, *args, **kwargs):

    def remove_fixed_ip(self, context, instance, *args, **kwargs):

    def get_diagnostics(self, context, instance):

    def rescue(self, context, instance, rescue_password=None):

    def unrescue(self, context, instance):

    def shelve(self, context, instance):

    def shelve_offload(self, context, instance):

    def unshelve(self, context, instance):

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

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

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

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

    def get_console_output(self, context, instance, *args, **kwargs):

    def lock(self, context, instance):

    def unlock(self, context, instance):

    def _attach_volume(self, context, instance, volume_id, device, disk_bus, device_type):

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

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

    def delete_instance_metadata(self, context, instance, key):

    def update_instance_metadata(self, context, instance, metadata, delete=False):

    def get_migrations(self, context, filters):

class ServiceProxy(object):

    def __init__(self, obj, cell_path):

    def id(self):

    def __getitem__(self, key):

    def __getattr__(self, key):

class HostAPI(compute_api.HostAPI):

    def __init__(self):

    def _assert_host_exists(self, context, host_name, must_be_up=False):

    def get_host_uptime(self, context, host_name):

    def service_get_all(self, context, filters=None, set_zones=False):

    def service_get_by_compute_host(self, context, host_name):

    def service_update(self, context, host_name, binary, params_to_update):

    def service_delete(self, context, service_id):

    def instance_get_all_by_host(self, context, host_name):

    def task_log_get_all(self, context, task_name, beginning, ending, host=None, state=None):

    def compute_node_get(self, context, compute_id):

    def compute_node_get_all(self, context):

    def compute_node_search_by_hypervisor(self, context, hypervisor_match):

    def compute_node_statistics(self, context):

class InstanceActionAPI(compute_api.InstanceActionAPI):

    def __init__(self):

    def actions_get(self, context, instance):

    def action_get_by_request_id(self, context, instance, request_id):

    def action_events_get(self, context, instance, action_id):

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

class NopClaim(object):

    def __init__(self, migration=None):

    def disk_gb(self):

    def memory_mb(self):

    def vcpus(self):

    def __enter__(self):

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

    def abort(self):

    def __str__(self):

class Claim(NopClaim):

    def __init__(self, instance, tracker, resources, overhead=None, limits=None):

    def disk_gb(self):

    def memory_mb(self):

    def vcpus(self):

    def abort(self):

    def _claim_test(self, resources, limits=None):

    def _test_memory(self, resources, limit):

    def _test_disk(self, resources, limit):

    def _test_pci(self):

    def _test_cpu(self, resources, limit):

    def _test(self, type_, unit, total, used, requested, limit):

class ResizeClaim(Claim):

    def __init__(self, instance, instance_type, tracker, resources, overhead=None, limits=None):

    def disk_gb(self):

    def memory_mb(self):

    def vcpus(self):

    def _test_pci(self):

    def abort(self):

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

def _int_or_none(val):

def create(name, memory, vcpus, root_gb, ephemeral_gb=0, flavorid=None, swap=0, rxtx_factor=1.0, is_public=True):

def destroy(name):

def get_all_flavors(ctxt=None, inactive=False, filters=None):

def get_all_flavors_sorted_list(ctxt=None, inactive=False, filters=None, sort_key='flavorid', sort_dir='asc', limit=None, marker=None):

def get_default_flavor():

def get_flavor(instance_type_id, ctxt=None, inactive=False):

def get_flavor_by_name(name, ctxt=None):

def get_flavor_by_flavor_id(flavorid, ctxt=None, read_deleted="yes"):

def get_flavor_access_by_flavor_id(flavorid, ctxt=None):

def add_flavor_access(flavorid, projectid, ctxt=None):

def remove_flavor_access(flavorid, projectid, ctxt=None):

def extract_flavor(instance, prefix=''):

def save_flavor_info(metadata, instance_type, prefix=''):

def delete_flavor_info(metadata, *prefixes):

def validate_extra_spec_keys(key_names_list):

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

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

def errors_out_migration(function):

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

OpenStack Index

Previous

Next