@

Home 

OpenStack Study: nova

OpenStack Index

Previous

Next

def normalize_time(timestamp):

def is_older_than(before, seconds):

def is_newer_than(after, seconds):

def utcnow_ts():

def utcnow():

def iso8601_from_timestamp(timestamp):

def set_time_override(override_time=None):

def advance_time_delta(timedelta):

def advance_time_seconds(seconds):

def clear_time_override():

def marshall_now(now=None):

def unmarshall_time(tyme):

def delta_seconds(before, after):

def total_seconds(delta):

def is_soon(dt, window):

\OpenStack\nova-2014.1\nova\openstack\common\units.py

\OpenStack\nova-2014.1\nova\openstack\common\uuidutils.py

def generate_uuid():

def is_uuid_like(val):

\OpenStack\nova-2014.1\nova\openstack\common\versionutils.py

def is_compatible(requested_version, current_version, same_major=True):

\OpenStack\nova-2014.1\nova\openstack\common\xmlutils.py

class ProtectedExpatParser(expatreader.ExpatParser):

    def __init__(self, forbid_dtd=True, forbid_entities=True, *args, **kwargs):

    def start_doctype_decl(self, name, sysid, pubid, has_internal_subset):

    def entity_decl(self, entityName, is_parameter_entity, value, base, systemId, publicId, notationName):

    def unparsed_entity_decl(self, name, base, sysid, pubid, notation_name):

    def external_entity_ref(self, context, base, systemId, publicId):

    def notation_decl(self, name, base, sysid, pubid):

    def reset(self):

def safe_minidom_parse_string(xml_string):

\OpenStack\nova-2014.1\nova\openstack\common\__init__.py

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

\OpenStack\nova-2014.1\nova\paths.py

def basedir_def(*args):

def bindir_def(*args):

def state_path_def(*args):

def basedir_rel(*args):

def bindir_rel(*args):

def state_path_rel(*args):

\OpenStack\nova-2014.1\nova\pci\pci_manager.py

class PciDevTracker(object):

    def __init__(self, node_id=None):

    def _initial_instance_usage(self):

    def _filter_devices_for_spec(self, request_spec, pci_devs):

    def _get_free_devices_for_request(self, pci_request, pci_devs):

    def free_devs(self):

    def get_free_devices_for_requests(self, pci_requests):

    def all_devs(self):

    def save(self, context):

    def pci_stats(self):

    def set_hvdevs(self, devices):

    def _claim_instance(self, instance, prefix=''):

    def _allocate_instance(self, instance, devs):

    def _free_device(self, dev, instance=None):

    def _free_instance(self, instance):

    def update_pci_for_instance(self, instance):

    def update_pci_for_migration(self, instance, sign=1):

    def clean_usage(self, instances, migrations, orphans):

    def set_compute_node_id(self, node_id):

def get_instance_pci_devs(inst):

\OpenStack\nova-2014.1\nova\pci\pci_request.py

def _get_alias_from_config():

def _translate_alias_to_requests(alias_spec):

def get_pci_requests_from_flavor(flavor):

def get_instance_pci_requests(instance, prefix=""):

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

def delete_flavor_pci_info(metadata, *prefixes):

\OpenStack\nova-2014.1\nova\pci\pci_stats.py

class PciDeviceStats(object):

    def __init__(self, stats=None):

    def _equal_properties(self, dev, entry):

    def _get_first_pool(self, dev):

    def add_device(self, dev):

    def _decrease_pool_count(pool_list, pool, count=1):

    def consume_device(self, dev):

    def _filter_pools_for_spec(pools, request_specs):

    def _apply_request(self, pools, request):

    def support_requests(self, requests):

    def apply_requests(self, requests):

    def __iter__(self):

    def clear(self):

\OpenStack\nova-2014.1\nova\pci\pci_utils.py

def pci_device_prop_match(pci_dev, specs):

def parse_address(address):

\OpenStack\nova-2014.1\nova\pci\pci_whitelist.py

class PciHostDevicesWhiteList(object):

    def _parse_white_list_from_config(self, whitelists):

    def __init__(self, whitelist_spec=None):

    def device_assignable(self, dev):

def get_pci_devices_filter():

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

\OpenStack\nova-2014.1\nova\policy.py

def reset():

def init():

def _set_rules(data):

def enforce(context, action, target, do_raise=True):

def check_is_admin(context):

class IsAdminCheck(policy.Check):

    def __init__(self, kind, match):

    def __call__(self, target, creds):

def get_rules():

\OpenStack\nova-2014.1\nova\quota.py

class DbQuotaDriver(object):

    def get_by_project_and_user(self, context, project_id, user_id, resource):

    def get_by_project(self, context, project_id, resource):

    def get_by_class(self, context, quota_class, resource):

    def get_defaults(self, context, resources):

    def get_class_quotas(self, context, resources, quota_class, defaults=True):

    def _process_quotas(self, context, resources, project_id, quotas, quota_class=None, defaults=True, usages=None, remains=False):

    def get_user_quotas(self, context, resources, project_id, user_id, quota_class=None, defaults=True, usages=True, project_quotas=None, user_quotas=None):

    def get_project_quotas(self, context, resources, project_id, quota_class=None, defaults=True, usages=True, remains=False, project_quotas=None):

    def get_settable_quotas(self, context, resources, project_id, user_id=None):

    def _get_quotas(self, context, resources, keys, has_sync, project_id=None, user_id=None, project_quotas=None):

    def limit_check(self, context, resources, values, project_id=None, user_id=None):

    def reserve(self, context, resources, deltas, expire=None, project_id=None, user_id=None):

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

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

    def usage_reset(self, context, resources):

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

    def destroy_all_by_project(self, context, project_id):

    def expire(self, context):

class NoopQuotaDriver(object):

    def get_by_project_and_user(self, context, project_id, user_id, resource):

    def get_by_project(self, context, project_id, resource):

    def get_by_class(self, context, quota_class, resource):

    def get_defaults(self, context, resources):

    def get_class_quotas(self, context, resources, quota_class, defaults=True):

    def _get_noop_quotas(self, resources, usages=None, remains=False):

    def get_user_quotas(self, context, resources, project_id, user_id, quota_class=None, defaults=True, usages=True):

    def get_project_quotas(self, context, resources, project_id, quota_class=None, defaults=True, usages=True, remains=False):

    def get_settable_quotas(self, context, resources, project_id, user_id=None):

    def limit_check(self, context, resources, values, project_id=None, user_id=None):

    def reserve(self, context, resources, deltas, expire=None, project_id=None, user_id=None):

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

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

    def usage_reset(self, context, resources):

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

    def destroy_all_by_project(self, context, project_id):

    def expire(self, context):

class BaseResource(object):

    def __init__(self, name, flag=None):

    def quota(self, driver, context, **kwargs):

    def default(self):

class ReservableResource(BaseResource):

    def __init__(self, name, sync, flag=None):

class AbsoluteResource(BaseResource):

class CountableResource(AbsoluteResource):

    def __init__(self, name, count, flag=None):

class QuotaEngine(object):

    def __init__(self, quota_driver_class=None):

    def _driver(self):

    def __contains__(self, resource):

    def register_resource(self, resource):

    def register_resources(self, resources):

    def get_by_project_and_user(self, context, project_id, user_id, resource):

    def get_by_project(self, context, project_id, resource):

    def get_by_class(self, context, quota_class, resource):

    def get_defaults(self, context):

    def get_class_quotas(self, context, quota_class, defaults=True):

    def get_user_quotas(self, context, project_id, user_id, quota_class=None, defaults=True, usages=True):

    def get_project_quotas(self, context, project_id, quota_class=None, defaults=True, usages=True, remains=False):

    def get_settable_quotas(self, context, project_id, user_id=None):

    def count(self, context, resource, *args, **kwargs):

    def limit_check(self, context, project_id=None, user_id=None, **values):

    def reserve(self, context, expire=None, project_id=None, user_id=None, **deltas):

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

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

    def usage_reset(self, context, resources):

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

    def destroy_all_by_project(self, context, project_id):

    def expire(self, context):

    def resources(self):

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

\OpenStack\nova-2014.1\nova\rpc.py

def init(conf):

def cleanup():

def set_defaults(control_exchange):

def add_extra_exmods(*args):

def clear_extra_exmods():

def get_allowed_exmods():

class JsonPayloadSerializer(messaging.NoOpSerializer):

    def serialize_entity(context, entity):

class RequestContextSerializer(messaging.Serializer):

    def __init__(self, base):

    def serialize_entity(self, context, entity):

    def deserialize_entity(self, context, entity):

    def serialize_context(self, context):

    def deserialize_context(self, context):

def get_transport_url(url_str=None):

def get_client(target, version_cap=None, serializer=None):

def get_server(target, endpoints, serializer=None):

def get_notifier(service=None, host=None, publisher_id=None):

\OpenStack\nova-2014.1\nova\safe_utils.py

def getcallargs(function, *args, **kwargs):

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

class BaremetalNodeState(host_manager.HostState):

    def update_from_compute_node(self, compute):

    def consume_from_instance(self, instance):

def new_host_state(self, host, node, capabilities=None, service=None):

class BaremetalHostManager(host_manager.HostManager):

    def __init__(self):

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

class CachingScheduler(filter_scheduler.FilterScheduler):

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

    def run_periodic_tasks(self, context):

    def _get_all_host_states(self, context):

    def _get_up_hosts(self, context):

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

class ChanceScheduler(driver.Scheduler):

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

    def _filter_hosts(self, request_spec, hosts, filter_properties):

    def _schedule(self, context, topic, request_spec, filter_properties):

    def select_destinations(self, context, request_spec, filter_properties):

    def schedule_run_instance(self, context, request_spec, admin_password, injected_files, requested_networks, is_first_time, filter_properties, legacy_bdm_in_spec):

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

def handle_schedule_error(context, ex, instance_uuid, request_spec):

def instance_update_db(context, instance_uuid, extra_values=None):

class Scheduler(object):

    def __init__(self):

    def run_periodic_tasks(self, context):

    def hosts_up(self, context, topic):

    def schedule_run_instance(self, context, request_spec, admin_password, injected_files, requested_networks, is_first_time, filter_properties, legacy_bdm_in_spec):

    def select_destinations(self, context, request_spec, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\affinity_filter.py

class AffinityFilter(filters.BaseHostFilter):

    def __init__(self):

class DifferentHostFilter(AffinityFilter):

    def host_passes(self, host_state, filter_properties):

class SameHostFilter(AffinityFilter):

    def host_passes(self, host_state, filter_properties):

class SimpleCIDRAffinityFilter(AffinityFilter):

    def host_passes(self, host_state, filter_properties):

class _GroupAntiAffinityFilter(AffinityFilter):

    def __init__(self):

    def host_passes(self, host_state, filter_properties):

class GroupAntiAffinityFilter(_GroupAntiAffinityFilter):

    def __init__(self):

class ServerGroupAntiAffinityFilter(_GroupAntiAffinityFilter):

    def __init__(self):

class _GroupAffinityFilter(AffinityFilter):

    def __init__(self):

    def host_passes(self, host_state, filter_properties):

class GroupAffinityFilter(_GroupAffinityFilter):

    def __init__(self):

class ServerGroupAffinityFilter(_GroupAffinityFilter):

    def __init__(self):

\OpenStack\nova-2014.1\nova\scheduler\filters\aggregate_image_properties_isolation.py

class AggregateImagePropertiesIsolation(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\aggregate_instance_extra_specs.py

class AggregateInstanceExtraSpecsFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\aggregate_multitenancy_isolation.py

class AggregateMultiTenancyIsolation(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\all_hosts_filter.py

class AllHostsFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\availability_zone_filter.py

class AvailabilityZoneFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\compute_capabilities_filter.py

class ComputeCapabilitiesFilter(filters.BaseHostFilter):

    def _satisfies_extra_specs(self, host_state, instance_type):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\compute_filter.py

class ComputeFilter(filters.BaseHostFilter):

    def __init__(self):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\core_filter.py

class BaseCoreFilter(filters.BaseHostFilter):

    def _get_cpu_allocation_ratio(self, host_state, filter_properties):

    def host_passes(self, host_state, filter_properties):

class CoreFilter(BaseCoreFilter):

    def _get_cpu_allocation_ratio(self, host_state, filter_properties):

class AggregateCoreFilter(BaseCoreFilter):

    def _get_cpu_allocation_ratio(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\disk_filter.py

class DiskFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\extra_specs_ops.py

def match(value, req):

\OpenStack\nova-2014.1\nova\scheduler\filters\image_props_filter.py

class ImagePropertiesFilter(filters.BaseHostFilter):

    def _instance_supported(self, host_state, image_props, hypervisor_version):

        def _compare_props(props, other_props):

        def _compare_product_version(hyper_version, image_props):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\io_ops_filter.py

class IoOpsFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\isolated_hosts_filter.py

class IsolatedHostsFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\json_filter.py

class JsonFilter(filters.BaseHostFilter):

    def _op_compare(self, args, op):

    def _equals(self, args):

    def _less_than(self, args):

    def _greater_than(self, args):

    def _in(self, args):

    def _less_than_equal(self, args):

    def _greater_than_equal(self, args):

    def _not(self, args):

    def _or(self, args):

    def _and(self, args):

    def _parse_string(self, string, host_state):

    def _process_filter(self, query, host_state):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\metrics_filter.py

class MetricsFilter(filters.BaseHostFilter):

    def __init__(self):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\num_instances_filter.py

class NumInstancesFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\pci_passthrough_filter.py

class PciPassthroughFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\ram_filter.py

class BaseRamFilter(filters.BaseHostFilter):

    def _get_ram_allocation_ratio(self, host_state, filter_properties):

    def host_passes(self, host_state, filter_properties):

class RamFilter(BaseRamFilter):

    def _get_ram_allocation_ratio(self, host_state, filter_properties):

class AggregateRamFilter(BaseRamFilter):

    def _get_ram_allocation_ratio(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\retry_filter.py

class RetryFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\trusted_filter.py

class HTTPSClientAuthConnection(httplib.HTTPSConnection):

    def __init__(self, host, port, key_file, cert_file, ca_file, timeout=None):

    def connect(self):

class AttestationService(object):

    def __init__(self):

    def _do_request(self, method, action_url, body, headers):

    def _request(self, cmd, subcmd, hosts):

    def do_attestation(self, hosts):

class ComputeAttestationCache(object):

    def __init__(self):

    def _cache_valid(self, host):

    def _init_cache_entry(self, host):

    def _invalidate_caches(self):

    def _update_cache_entry(self, state):

    def _update_cache(self):

    def get_host_attestation(self, host):

class ComputeAttestation(object):

    def __init__(self):

    def is_trusted(self, host, trust):

class TrustedFilter(filters.BaseHostFilter):

    def __init__(self):

    def host_passes(self, host_state, filter_properties):

\OpenStack\nova-2014.1\nova\scheduler\filters\type_filter.py

class TypeAffinityFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

class AggregateTypeAffinityFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

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

class BaseHostFilter(filters.BaseFilter):

    def _filter_one(self, obj, filter_properties):

    def host_passes(self, host_state, filter_properties):

class HostFilterHandler(filters.BaseFilterHandler):

    def __init__(self):

def all_filters():

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

class FilterScheduler(driver.Scheduler):

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

    def schedule_run_instance(self, context, request_spec, admin_password, injected_files, requested_networks, is_first_time, filter_properties, legacy_bdm_in_spec):

    def select_destinations(self, context, request_spec, filter_properties):

    def _provision_resource(self, context, weighed_host, request_spec, filter_properties, requested_networks, injected_files, admin_password, is_first_time, instance_uuid=None, legacy_bdm_in_spec=True):

    def _get_configuration_options(self):

    def populate_filter_properties(self, request_spec, filter_properties):

    def _max_attempts(self):

    def _log_compute_error(self, instance_uuid, retry):

    def _populate_retry(self, filter_properties, instance_properties):

    def _setup_instance_group(context, filter_properties):

    def _schedule(self, context, request_spec, filter_properties, instance_uuids=None):

    def _get_all_host_states(self, context):

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

class ReadOnlyDict(UserDict.IterableUserDict):

    def __init__(self, source=None):

    def __setitem__(self, key, item):

    def __delitem__(self, key):

    def clear(self):

    def pop(self, key, *args):

    def popitem(self):

    def update(self, source=None):

class HostState(object):

    def __init__(self, host, node, capabilities=None, service=None):

    def update_capabilities(self, capabilities=None, service=None):

    def _update_metrics_from_compute_node(self, compute):

    def update_from_compute_node(self, compute):

    def consume_from_instance(self, instance):

    def __repr__(self):

class HostManager(object):

    def __init__(self):

    def _choose_host_filters(self, filter_cls_names):

    def get_filtered_hosts(self, hosts, filter_properties, filter_class_names=None, index=0):

        def _strip_ignore_hosts(host_map, hosts_to_ignore):

        def _match_forced_hosts(host_map, hosts_to_force):

        def _match_forced_nodes(host_map, nodes_to_force):

    def get_weighed_hosts(self, hosts, weight_properties):

    def get_all_host_states(self, context):

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

class SchedulerManager(manager.Manager):

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

    def create_volume(self, context, volume_id, snapshot_id, reservations=None, image_id=None):

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

    def _schedule_live_migration(self, context, instance, dest, block_migration, disk_over_commit):

    def run_instance(self, context, request_spec, admin_password, injected_files, requested_networks, is_first_time, filter_properties, legacy_bdm_in_spec=True):

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

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

    def show_host_resources(self, context, host):

    def _expire_reservations(self, context):

    def _run_periodic_tasks(self, context):

    def get_backdoor_port(self, context):

    def select_hosts(self, context, request_spec, filter_properties):

    def select_destinations(self, context, request_spec, filter_properties):

class _SchedulerManagerV3Proxy(object):

    def __init__(self, manager):

    def select_destinations(self, ctxt, request_spec, filter_properties):

    def run_instance(self, ctxt, request_spec, admin_password, injected_files, requested_networks, is_first_time, filter_properties, legacy_bdm_in_spec):

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

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

class SchedulerAPI(object):

    def __init__(self):

    def select_destinations(self, ctxt, request_spec, filter_properties):

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

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

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

class SchedulerOptions(object):

    def __init__(self):

    def _get_file_handle(self, filename):

    def _get_file_timestamp(self, filename):

    def _load_file(self, handle):

    def _get_time_now(self):

    def get_configuration(self, filename=None):

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

def build_request_spec(ctxt, image, instances, instance_type=None):

def set_vm_state_and_notify(context, service, method, updates, ex, request_spec, db):

def populate_filter_properties(filter_properties, host_state):

def _add_retry_host(filter_properties, host, node):

def parse_options(opts, sep='=', converter=str, name=""):

\OpenStack\nova-2014.1\nova\scheduler\weights\metrics.py

class MetricsWeigher(weights.BaseHostWeigher):

    def __init__(self):

    def _parse_setting(self):

    def weight_multiplier(self):

    def _weigh_object(self, host_state, weight_properties):

\OpenStack\nova-2014.1\nova\scheduler\weights\ram.py

class RAMWeigher(weights.BaseHostWeigher):

    def weight_multiplier(self):

    def _weigh_object(self, host_state, weight_properties):

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

class WeighedHost(weights.WeighedObject):

    def to_dict(self):

    def __repr__(self):

class BaseHostWeigher(weights.BaseWeigher):

class HostWeightHandler(weights.BaseWeightHandler):

    def __init__(self):

def all_weighers():

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

\OpenStack\nova-2014.1\nova\service.py

class Service(service.Service):

    def __init__(self, host, binary, topic, manager, report_interval=None, periodic_enable=None, periodic_fuzzy_delay=None, periodic_interval_max=None, db_allowed=True, *args, **kwargs):

    def start(self):

    def _create_service_ref(self, context):

    def __getattr__(self, key):

    def create(cls, host=None, binary=None, topic=None, manager=None, report_interval=None, periodic_enable=None, periodic_fuzzy_delay=None, periodic_interval_max=None, db_allowed=True):

    def kill(self):

    def stop(self):

    def periodic_tasks(self, raise_on_error=False):

    def basic_config_check(self):

class WSGIService(object):

    def __init__(self, name, loader=None, use_ssl=False, max_url_len=None):

    def _get_manager(self):

    def start(self):

    def stop(self):

    def wait(self):

def process_launcher():

def serve(server, workers=None):

def wait():

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

class API(object):

    def __new__(cls, *args, **kwargs):

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

    def basic_config_check(self):

    def join(self, member_id, group_id, service=None):

    def service_is_up(self, member):

    def leave(self, member_id, group_id):

    def get_all(self, group_id):

    def get_one(self, group_id):

class ServiceGroupDriver(object):

    def join(self, member_id, group_id, service=None):

    def is_up(self, member):

    def leave(self, member_id, group_id):

    def get_all(self, group_id):

    def get_one(self, group_id):

\OpenStack\nova-2014.1\nova\servicegroup\drivers\db.py

class DbDriver(api.ServiceGroupDriver):

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

    def join(self, member_id, group_id, service=None):

    def is_up(self, service_ref):

    def get_all(self, group_id):

    def _report_state(self, service):

\OpenStack\nova-2014.1\nova\servicegroup\drivers\mc.py

class MemcachedDriver(api.ServiceGroupDriver):

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

    def join(self, member_id, group_id, service=None):

    def is_up(self, service_ref):

    def get_all(self, group_id):

    def _report_state(self, service):

\OpenStack\nova-2014.1\nova\servicegroup\drivers\zk.py

class ZooKeeperDriver(api.ServiceGroupDriver):

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

    def join(self, member_id, group, service=None):

    def leave(self, member_id, group):

    def is_up(self, service_ref):

    def get_all(self, group_id):

class FakeLoopingCall(loopingcall.LoopingCallBase):

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

    def stop(self):

    def start(self, interval, initial_delay=None):

    def wait(self):

\OpenStack\nova-2014.1\nova\servicegroup\drivers\__init__.py

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

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

\OpenStack\nova-2014.1\nova\storage\linuxscsi.py

def echo_scsi_command(path, content):

def rescan_hosts(hbas):

def get_device_list():

def get_device_info(device):

def _wait_for_remove(device, tries):

def remove_device(device):

def find_multipath_device(device):

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

\OpenStack\nova-2014.1\nova\test.py

class Database(fixtures.Fixture):

    def __init__(self, db_session, db_migrate, sql_connection, sqlite_db, sqlite_clean_db):

    def setUp(self):

class SampleNetworks(fixtures.Fixture):

    def __init__(self, host=None):

    def setUp(self):

class ReplaceModule(fixtures.Fixture):

    def __init__(self, name, new_value):

    def _restore(self, old_value):

    def setUp(self):

class ServiceFixture(fixtures.Fixture):

    def __init__(self, name, host=None, **kwargs):

    def setUp(self):

class TranslationFixture(fixtures.Fixture):

    def setUp(self):

class TestingException(Exception):

class TestCase(testtools.TestCase):

    def setUp(self):

    def _restore_obj_registry(self):

    def _clear_attrs(self):

    def flags(self, **kw):

    def start_service(self, name, host=None, **kwargs):

class APICoverage(object):

    def test_api_methods(self):

class TimeOverride(fixtures.Fixture):

    def setUp(self):

class NoDBTestCase(TestCase):

\OpenStack\nova-2014.1\nova\tests\api\ec2\test_api.py

class FakeHttplibSocket(object):

    def __init__(self, response_string):

    def makefile(self, _mode, _other):

class FakeHttplibConnection(object):

    def __init__(self, app, host, is_secure=False):

    def request(self, method, path, data, headers):

    def getresponse(self):

    def getresponsebody(self):

    def close(self):

class XmlConversionTestCase(test.TestCase):

    def test_number_conversion(self):

class Ec2utilsTestCase(test.TestCase):

    def test_ec2_id_to_id(self):

    def test_bad_ec2_id(self):

    def test_id_to_ec2_id(self):

    def test_dict_from_dotted_str(self):

    def test_properties_root_defice_name(self):

    def test_regex_from_ec2_regex(self):

        def _test_re(ec2_regex, expected, literal, match=True):

    def test_mapping_prepend_dev(self):

class ApiEc2TestCase(test.TestCase):

    def setUp(self):

    def expect_http(self, host=None, is_secure=False, api_version=None):

    def test_return_valid_isoformat(self):

    def test_xmlns_version_matches_request_version(self):

    def test_describe_instances(self):

    def test_terminate_invalid_instance(self):

    def test_get_all_key_pairs(self):

    def test_create_duplicate_key_pair(self):

    def test_get_all_security_groups(self):

    def test_create_delete_security_group(self):

    def test_group_name_valid_chars_security_group(self):

    def test_group_name_valid_length_security_group(self):

    def test_authorize_revoke_security_group_cidr(self):

        def _assert(message, *args):

    def test_authorize_revoke_security_group_cidr_v6(self):

    def test_authorize_revoke_security_group_foreign_group(self):

\OpenStack\nova-2014.1\nova\tests\api\ec2\test_cinder_cloud.py

def get_fake_cache():

 def _ip(ip, fixed=True, floats=None):

def get_instances_with_cached_ips(orig_func, *args, **kwargs):

class CinderCloudTestCase(test.TestCase):

    def setUp(self):

        def fake_show(meh, context, id):

        def fake_detail(_self, context, **kwargs):

        def dumb(*args, **kwargs):

    def tearDown(self):

    def _stub_instance_get_with_fixed_ips(self, func_name):

        def fake_get(*args, **kwargs):

    def _create_key(self, name):

    def test_describe_volumes(self):

    def test_format_volume_maps_status(self):

    def test_create_volume_in_availability_zone(self):

    def test_create_volume_from_snapshot(self):

    def test_describe_snapshots(self):

    def test_format_snapshot_maps_status(self):

    def test_create_snapshot(self):

    def test_delete_snapshot(self):

    def _block_device_mapping_create(self, instance_uuid, mappings):

    def _setUpBlockDeviceMapping(self):

    def _tearDownBlockDeviceMapping(self, inst1, inst2, volumes):

    def test_format_instance_bdm(self):

    def _assertInstance(self, instance_id):

    def _assertEqualBlockDeviceMapping(self, expected, result):

    def test_describe_instances_bdm(self):

    def _setUpImageSet(self, create_volumes_and_snapshots=False):

        def fake_show(meh, context, image_id):

        def fake_detail(meh, context):

    def _assertImageSet(self, result, root_device_type, root_device_name):

    def _run_instance(self, **kwargs):

    def _restart_compute_service(self, periodic_interval_max=None):

    def _volume_create(self, volume_id=None):

    def _assert_volume_attached(self, vol, instance_uuid, mountpoint):

    def _assert_volume_detached(self, vol):

    def test_stop_start_with_volume(self):

    def test_stop_with_attached_volume(self):

    def _create_snapshot(self, ec2_volume_id):

    def test_run_with_snapshot(self):

    def test_create_image(self):

    def _fake_bdm_get(ctxt, id):

\OpenStack\nova-2014.1\nova\tests\api\ec2\test_cloud.py

def get_fake_cache(get_floating):

 def _ip(ip, fixed=True, floats=None):

def get_instances_with_cached_ips(orig_func, get_floating, *args, **kwargs):

class CloudTestCase(test.TestCase):

    def setUp(self):

        def fake_show(meh, context, id):

        def fake_detail(_self, context, **kwargs):

        def dumb(*args, **kwargs):

    def tearDown(self):

    def fake_get_target(obj, iqn):

    def fake_remove_iscsi_target(obj, tid, lun, vol_id, **kwargs):

    def _stub_instance_get_with_fixed_ips(self, func_name, get_floating=True):

        def fake_get(*args, **kwargs):

    def _create_key(self, name):

    def test_describe_regions(self):

    def test_describe_addresses(self):

    def test_describe_specific_address(self):

    def test_allocate_address(self):

    def test_release_address(self):

    def test_associate_disassociate_address(self):

        def fake_update_instance_cache_with_nw_info(api, context, instance, nw_info=None, update_cells=True):

    def test_disassociate_auto_assigned_address(self):

        def fake_get(*args, **kwargs):

        def fake_disassociate_floating_ip(*args, **kwargs):

    def test_disassociate_unassociated_address(self):

    def test_describe_security_groups(self):

    def test_describe_security_groups_all_tenants(self):

        def _check_name(result, i, expected):

    def test_describe_security_groups_by_id(self):

    def test_create_delete_security_group(self):

    def test_security_group_quota_limit(self):

    def test_delete_security_group_by_id(self):

    def test_delete_security_group_with_bad_name(self):

    def test_delete_security_group_with_bad_group_id(self):

    def test_delete_security_group_no_params(self):

    def test_delete_security_group_policy_not_allowed(self):

    def test_authorize_security_group_ingress_policy_not_allowed(self):

    def test_authorize_security_group_ingress(self):

    def test_authorize_security_group_ingress_ip_permissions_ip_ranges(self):

    def test_authorize_security_group_fail_missing_source_group(self):

    def test_authorize_security_group_ingress_ip_permissions_groups(self):

    def test_describe_security_group_ingress_groups(self):

    def test_revoke_security_group_ingress_policy_not_allowed(self):

    def test_revoke_security_group_ingress(self):

    def test_authorize_revoke_security_group_ingress_by_id(self):

    def test_authorize_security_group_ingress_missing_protocol_params(self):

    def test_authorize_security_group_ingress_missing_group_name_or_id(self):

    def test_authorize_security_group_ingress_already_exists(self):

    def test_security_group_ingress_quota_limit(self):

    def _test_authorize_security_group_no_ports_with_source_group(self, proto):

    def _test_authorize_security_group_no_ports_no_source_group(self, proto):

    def test_authorize_security_group_no_ports_icmp(self):

    def test_authorize_security_group_no_ports_tcp(self):

    def test_authorize_security_group_no_ports_udp(self):

    def test_revoke_security_group_ingress_missing_group_name_or_id(self):

    def test_delete_security_group_in_use_by_group(self):

    def test_delete_security_group_in_use_by_instance(self):

    def test_describe_availability_zones(self):

    def test_describe_availability_zones_verbose(self):

    def assertEqualSorted(self, x, y):

    def test_describe_instances(self):

    def test_describe_instances_all_invalid(self):

    def test_describe_instances_with_filters(self):

    def test_describe_instances_with_filters_tags(self):

        def fake_change_instance_metadata(inst, ctxt, diff, instance=None, instance_uuid=None):

    def test_describe_instances_sorting(self):

    def test_describe_instance_state(self):

        def test_instance_state(expected_code, expected_name, power_state_, vm_state_, values=None):

    def test_describe_instances_no_ipv6(self):

    def test_describe_instances_deleted(self):

    def test_describe_instances_with_image_deleted(self):

    def test_describe_instances_dnsName_set(self):

    def test_describe_images(self):

        def fake_detail(meh, context, **kwargs):

        def fake_show_none(meh, context, id):

        def fake_detail_none(self, context, **kwargs):

    def assertDictListUnorderedMatch(self, L1, L2, key):

    def _setUpImageSet(self, create_volumes_and_snapshots=False):

        def fake_show(meh, context, image_id):

        def fake_detail(meh, context, **kwargs):

    def _assertImageSet(self, result, root_device_type, root_device_name):

    def test_describe_image_mapping(self):

    def test_describe_image_attribute(self):

        def fake_show(meh, context, id):

        def fake_detail(self, context, **kwargs):

    def test_describe_image_attribute_root_device_name(self):

    def test_describe_image_attribute_block_device_mapping(self):

    def test_modify_image_attribute(self):

        def fake_show(meh, context, id):

        def fake_detail(self, context, **kwargs):

        def fake_update(meh, context, image_id, metadata, data=None):

    def test_register_image(self):

        def fake_create(*args, **kwargs):

    def test_register_image_empty(self):

    def test_register_image_name(self):

        def fake_create(_self, context, metadata, data=None):

    def test_format_image(self):

    def test_deregister_image(self):

        def fake_delete(self, context, id):

        def fake_detail_empty(self, context, **kwargs):

    def test_deregister_image_wrong_container_type(self):

        def fake_delete(self, context, id):

    def _run_instance(self, **kwargs):

    def test_get_password_data(self):

    def test_console_output(self):

    def test_key_generation(self):

    def test_describe_key_pairs(self):

    def test_describe_bad_key_pairs(self):

    def test_import_key_pair(self):

    def test_import_key_pair_quota_limit(self):

    def test_create_key_pair(self):

    def test_create_key_pair_quota_limit(self):

    def test_delete_key_pair(self):

    def test_run_instances(self):

        def fake_show(self, context, id):

        def dumb(*args, **kwargs):

    def test_run_instances_invalid_maxcount(self):

        def fake_show(self, context, id):

    def test_run_instances_invalid_mincount(self):

        def fake_show(self, context, id):

    def test_run_instances_invalid_count(self):

        def fake_show(self, context, id):

    def test_run_instances_availability_zone(self):

        def fake_show(self, context, id):

        def fake_format(*args, **kwargs):

        def fake_create(*args, **kwargs):

    def test_empty_reservation_id_from_token(self):

        def fake_get_all_system_metadata(context, search_filts):

    def test_run_instances_idempotent(self):

        def fake_show(self, context, id):

        def dumb(*args, **kwargs):

    def test_run_instances_image_state_none(self):

        def fake_show_no_state(self, context, id):

    def test_run_instances_image_state_invalid(self):

        def fake_show_decrypt(self, context, id):

    def test_run_instances_image_status_active(self):

        def fake_show_stat_active(self, context, id):

        def fake_id_to_glance_id(context, id):

    def _restart_compute_service(self, periodic_interval_max=None):

    def test_stop_start_instance(self):

    def test_start_instances(self):

    def test_start_instances_policy_failed(self):

    def test_stop_instances(self):

    def test_stop_instances_policy_failed(self):

    def test_terminate_instances(self):

    def test_terminate_instances_invalid_instance_id(self):

    def test_terminate_instances_disable_terminate(self):

    def test_terminate_instances_two_instances(self):

    def test_reboot_instances(self):

    def _volume_create(self, volume_id=None):

    def _snapshot_create(self, snapshot_id=None):

    def _create_snapshot(self, ec2_volume_id):

    def _do_test_create_image(self, no_reboot):

        def fake_show(meh, context, id):

        def fake_block_device_mapping_get_all_by_instance(context, inst_id, use_slave=False):

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

        def fake_power_off(self, instance):

    def test_create_image_no_reboot(self):

    def test_create_image_with_reboot(self):

    def test_create_image_instance_store(self):

        def fake_block_device_mapping_get_all_by_instance(context, inst_id, use_slave=False):

    def _fake_bdm_get(ctxt, id):

    def test_describe_instance_attribute(self):

        def fake_get(ctxt, instance_id, want_objects=False):

        def fake_get_instance_uuid_by_ec2_id(ctxt, int_id):

    def test_instance_initiated_shutdown_behavior(self):

        def test_dia_iisb(expected_result, **kwargs):

        def fake_show(self, context, id_):

    def test_create_delete_tags(self):

        def fake_change_instance_metadata(inst, ctxt, diff, instance=None, instance_uuid=None):

    def test_describe_tags(self):

        def fake_change_instance_metadata(inst, ctxt, diff, instance=None, instance_uuid=None):

    def test_resource_type_from_id(self):

class CloudTestCaseNeutronProxy(test.TestCase):

    def setUp(self):

    def tearDown(self):

    def test_describe_security_groups(self):

    def test_describe_security_groups_by_id(self):

    def test_create_delete_security_group(self):

\OpenStack\nova-2014.1\nova\tests\api\ec2\test_ec2_validate.py

class EC2ValidateTestCase(test.TestCase):

    def setUp(self):

        def dumb(*args, **kwargs):

        def fake_show(meh, context, id):

        def fake_detail(self, context, **kwargs):

    def tearDown(self):

    def test_console_output(self):

    def test_describe_instance_attribute(self):

    def test_instance_lifecycle(self):

    def test_create_image(self):

    def test_create_snapshot(self):

    def test_describe_volumes(self):

    def test_delete_volume(self):

    def test_detach_volume(self):

class EC2TimestampValidationTestCase(test.TestCase):

    def test_validate_ec2_timestamp_valid(self):

    def test_validate_ec2_timestamp_old_format(self):

    def test_validate_ec2_timestamp_not_set(self):

    def test_validate_ec2_timestamp_ms_time_regex(self):

    def test_validate_ec2_timestamp_aws_sdk_format(self):

    def test_validate_ec2_timestamp_invalid_format(self):

    def test_validate_ec2_timestamp_advanced_time(self):

    def test_validate_ec2_timestamp_advanced_time_expired(self):

    def test_validate_ec2_req_timestamp_not_expired(self):

    def test_validate_ec2_req_timestamp_expired(self):

    def test_validate_ec2_req_expired(self):

    def test_validate_ec2_req_not_expired(self):

    def test_validate_Expires_timestamp_invalid_format(self):

    def test_validate_ec2_req_timestamp_Expires(self):

\OpenStack\nova-2014.1\nova\tests\api\ec2\test_error_response.py

class TestClientExceptionEC2(Exception):

class TestServerExceptionEC2(Exception):

class Ec2ErrorResponseTestCase(test.NoDBTestCase):

    def setUp(self):

    def _validate_ec2_error(self, response, http_status, ec2_code, msg=None, unknown_msg=False):

    def test_exception_ec2_4xx(self):

    def test_exception_ec2_5xx(self):

    def test_unexpected_exception_ec2_4xx(self):

    def test_unexpected_exception_ec2_5xx(self):

    def test_unexpected_exception_builtin(self):

\OpenStack\nova-2014.1\nova\tests\api\ec2\test_faults.py

class TestFaults(test.NoDBTestCase):

    def test_fault_exception(self):

    def test_fault_exception_status_int(self):

    def test_fault_call(self):

\OpenStack\nova-2014.1\nova\tests\api\ec2\test_middleware.py

OpenStack Index

Previous

Next