@

Home 

OpenStack Study: nova

OpenStack Index

Previous

Next

class InstanceActionEvent(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, event, db_event):

    def get_by_id(cls, context, action_id, event_id):

    def event_start(cls, context, instance_uuid, event_name, want_result=True):

    def event_finish_with_failure(cls, context, instance_uuid, event_name, exc_val=None, exc_tb=None, want_result=None):

    def event_finish(cls, context, instance_uuid, event_name, want_result=True):

    def finish_with_failure(self, context, exc_val, exc_tb):

    def finish(self, context):

class InstanceActionEventList(base.ObjectListBase, base.NovaObject):

    def get_by_action(cls, context, action_id):

\OpenStack\nova-2014.1\nova\objects\instance_fault.py

class InstanceFault(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, fault, db_fault):

    def get_latest_for_instance(cls, context, instance_uuid):

class InstanceFaultList(base.ObjectListBase, base.NovaObject):

    def get_by_instance_uuids(cls, context, instance_uuids):

\OpenStack\nova-2014.1\nova\objects\instance_group.py

class InstanceGroup(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, instance_group, db_inst):

    def get_by_uuid(cls, context, uuid):

    def get_by_name(cls, context, name):

    def save(self, context):

    def refresh(self, context):

    def create(self, context):

    def destroy(self, context):

    def add_members(cls, context, group_uuid, instance_uuids):

    def get_hosts(self, context, exclude=None):

class InstanceGroupList(base.ObjectListBase, base.NovaObject):

    def get_by_project_id(cls, context, project_id):

    def get_all(cls, context):

\OpenStack\nova-2014.1\nova\objects\instance_info_cache.py

class InstanceInfoCache(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, info_cache, db_obj):

    def new(cls, context, instance_uuid):

    def get_by_instance_uuid(cls, context, instance_uuid):

    def _info_cache_cells_update(ctxt, info_cache):

    def save(self, context, update_cells=True):

    def delete(self, context):

    def refresh(self, context):

\OpenStack\nova-2014.1\nova\objects\keypair.py

class KeyPair(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, keypair, db_keypair):

    def get_by_name(cls, context, user_id, name):

    def destroy_by_name(cls, context, user_id, name):

    def create(self, context):

    def destroy(self, context):

class KeyPairList(base.ObjectListBase, base.NovaObject):

    def get_by_user(cls, context, user_id):

    def get_count_by_user(cls, context, user_id):

\OpenStack\nova-2014.1\nova\objects\migration.py

class Migration(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, migration, db_migration):

    def get_by_id(cls, context, migration_id):

    def get_by_instance_and_status(cls, context, instance_uuid, status):

    def create(self, context):

    def save(self, context):

    def instance(self):

class MigrationList(base.ObjectListBase, base.NovaObject):

    def get_unconfirmed_by_dest_compute(cls, context, confirm_window, dest_compute, use_slave=False):

    def get_in_progress_by_host_and_node(cls, context, host, node):

    def get_by_filters(cls, context, filters):

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

class Network(obj_base.NovaPersistentObject, obj_base.NovaObject):

    def _convert_legacy_ipv6_netmask(netmask):

    def _from_db_object(context, network, db_network):

    def get_by_id(cls, context, network_id, project_only='allow_none'):

    def get_by_uuid(cls, context, network_uuid):

    def get_by_cidr(cls, context, cidr):

    def associate(cls, context, project_id, network_id=None, force=False):

    def disassociate(cls, context, network_id, host=False, project=False):

    def in_use_on_host(cls, context, network_id, host):

    def _get_primitive_changes(self):

    def create(self, context):

    def destroy(self, context):

    def save(self, context):

class NetworkList(obj_base.ObjectListBase, obj_base.NovaObject):

    def get_all(cls, context, project_only='allow_none'):

    def get_by_uuids(cls, context, network_uuids, project_only='allow_none'):

    def get_by_host(cls, context, host):

    def get_by_project(cls, context, project_id, associate=True):

\OpenStack\nova-2014.1\nova\objects\pci_device.py

def check_device_status(dev_status=None):

 def outer(f):

class PciDevice(base.NovaPersistentObject, base.NovaObject):

    def update_device(self, dev_dict):

    def __init__(self):

    def _from_db_object(context, pci_device, db_dev):

    def get_by_dev_addr(cls, context, compute_node_id, dev_addr):

    def get_by_dev_id(cls, context, id):

    def create(cls, dev_dict):

    def claim(self, instance):

    def allocate(self, instance):

    def remove(self):

    def free(self, instance=None):

    def save(self, context):

class PciDeviceList(base.ObjectListBase, base.NovaObject):

    def __init__(self):

    def get_by_compute_node(cls, context, node_id):

    def get_by_instance_uuid(cls, context, uuid):

\OpenStack\nova-2014.1\nova\objects\quotas.py

def ids_from_instance(context, instance):

def ids_from_security_group(context, security_group):

class Quotas(base.NovaObject):

    def __init__(self):

    def from_reservations(cls, context, reservations, instance=None):

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

    def commit(self, context=None):

    def rollback(self, context=None):

class QuotasNoOp(Quotas):

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

    def commit(self, context=None):

    def rollback(self, context=None):

\OpenStack\nova-2014.1\nova\objects\security_group.py

class SecurityGroup(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, secgroup, db_secgroup):

    def get(cls, context, secgroup_id):

    def get_by_name(cls, context, project_id, group_name):

    def in_use(self, context):

    def save(self, context):

    def refresh(self, context):

class SecurityGroupList(base.ObjectListBase, base.NovaObject):

    def __init__(self):

    def get_all(cls, context):

    def get_by_project(cls, context, project_id):

    def get_by_instance(cls, context, instance):

def make_secgroup_list(security_groups):

\OpenStack\nova-2014.1\nova\objects\security_group_rule.py

class SecurityGroupRule(base.NovaPersistentObject, base.NovaObject):

    def _from_db_subgroup(context, db_group):

    def _from_db_object(context, rule, db_rule, expected_attrs=None):

    def get_by_id(cls, context, rule_id):

class SecurityGroupRuleList(base.ObjectListBase, base.NovaObject):

    def get_by_security_group_id(cls, context, secgroup_id):

    def get_by_security_group(cls, context, security_group):

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

class Service(base.NovaPersistentObject, base.NovaObject):

    def _do_compute_node(context, service, db_service):

    def _from_db_object(context, service, db_service):

    def obj_load_attr(self, attrname):

    def get_by_id(cls, context, service_id):

    def get_by_host_and_topic(cls, context, host, topic):

    def get_by_compute_host(cls, context, host):

    def get_by_args(cls, context, host, binary):

    def create(self, context):

    def save(self, context):

    def destroy(self, context):

class ServiceList(base.ObjectListBase, base.NovaObject):

    def get_by_topic(cls, context, topic):

    def get_by_host(cls, context, host):

    def get_all(cls, context, disabled=None, set_zones=False):

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

def datetime_or_none(dt):

def datetime_or_str_or_none(val):

def int_or_none(val):

def str_value(val):

def str_or_none(val):

def cstring(val):

def ip_or_none(version):

def nested_object(objclass, none_ok=True):

def network_model_or_none(val):

def list_of_strings_or_none(val):

def dict_of_strings_or_none(val):

def dt_serializer(name):

def dt_deserializer(instance, val):

def obj_serializer(name):

\OpenStack\nova-2014.1\nova\objects\virtual_interface.py

class VirtualInterface(base.NovaPersistentObject, base.NovaObject):

    def _from_db_object(context, vif, db_vif):

    def get_by_id(cls, context, vif_id):

    def get_by_uuid(cls, context, vif_uuid):

    def get_by_address(cls, context, address):

    def get_by_instance_and_network(cls, context, instance_uuid, network_id):

    def create(self, context):

    def delete_by_instance_uuid(cls, context, instance_uuid):

class VirtualInterfaceList(base.ObjectListBase, base.NovaObject):

    def get_all(cls, context):

    def get_by_instance_uuid(cls, context, instance_uuid, use_slave=False):

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

def register_all():

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

def get_wsgi_server():

class S3Application(wsgi.Router):

    def __init__(self, root_directory, bucket_depth=0, mapper=None):

class BaseRequestHandler(object):

    def __init__(self, application):

    def __call__(self, request):

    def get_argument(self, arg, default):

    def set_header(self, header, value):

    def set_status(self, status_code):

    def set_404(self):

    def finish(self, body=''):

    def invalid(self, **kwargs):

    def render_xml(self, value):

    def _render_parts(self, value, parts=None):

    def _object_path(self, bucket, object_name):

class RootHandler(BaseRequestHandler):

    def get(self):

class BucketHandler(BaseRequestHandler):

    def get(self, bucket_name):

    def put(self, bucket_name):

    def delete(self, bucket_name):

    def head(self, bucket_name):

class ObjectHandler(BaseRequestHandler):

    def get(self, bucket, object_name):

    def put(self, bucket, object_name):

    def delete(self, bucket, object_name):

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

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

class MissingArgs(Exception):

    def __init__(self, missing):

    def __str__(self):

def validate_args(fn, *args, **kwargs):

    def isbound(method):

\OpenStack\nova-2014.1\nova\openstack\common\config\generator.py

def generate(argv):

def _import_module(mod_str):

def _is_in_group(opt, group):

def _guess_groups(opt, mod_obj):

def _list_opts(obj):

def print_group_opts(group, opts_by_module):

def _get_my_ip():

def _sanitize_default(name, value):

def _print_opt(opt):

def main():

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

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

def generate_request_id():

class RequestContext(object):

    def __init__(self, auth_token=None, user=None, tenant=None, is_admin=False, read_only=False, show_deleted=False, request_id=None):

    def to_dict(self):

def get_admin_context(show_deleted=False):

def get_context_from_function_and_args(function, args, kwargs):

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

def safe_for_db_retry(f):

class wrap_db_retry(object):

    def __init__(self, retry_interval, max_retries, inc_retry_interval, max_retry_interval):

    def __call__(self, f):

        def wrapper(*args, **kwargs):

class DBAPI(object):

    def __init__(self, backend_name, backend_mapping=None, lazy=False, **kwargs):

    def _load_backend(self):

    def __getattr__(self, key):

\OpenStack\nova-2014.1\nova\openstack\common\db\exception.py

class DBError(Exception):

    def __init__(self, inner_exception=None):

class DBDuplicateEntry(DBError):

    def __init__(self, columns=[], inner_exception=None):

class DBDeadlock(DBError):

    def __init__(self, inner_exception=None):

class DBInvalidUnicodeParameter(Exception):

class DbMigrationError(DBError):

    def __init__(self, message=None):

class DBConnectionError(DBError):

\OpenStack\nova-2014.1\nova\openstack\common\db\options.py

def set_defaults(sql_connection, sqlite_db, max_pool_size=None, max_overflow=None, pool_timeout=None):

def list_opts():

\OpenStack\nova-2014.1\nova\openstack\common\db\sqlalchemy\migration.py

def _get_unique_constraints(self, table):

def _recreate_table(self, table, column=None, delta=None, omit_uniques=None):

def _visit_migrate_unique_constraint(self, *p, **k):

def patch_migrate():

def db_sync(engine, abs_path, version=None, init_version=0):

def _db_schema_sanity_check(engine):

def db_version(engine, abs_path, init_version):

def db_version_control(engine, abs_path, version=None):

def _find_migrate_repo(abs_path):

\OpenStack\nova-2014.1\nova\openstack\common\db\sqlalchemy\models.py

class ModelBase(object):

    def save(self, session):

    def __setitem__(self, key, value):

    def __getitem__(self, key):

    def get(self, key, default=None):

    def _extra_keys(self):

    def __iter__(self):

    def next(self):

    def update(self, values):

    def iteritems(self):

class TimestampMixin(object):

class SoftDeleteMixin(object):

    def soft_delete(self, session):

\OpenStack\nova-2014.1\nova\openstack\common\db\sqlalchemy\provision.py

def _gen_credentials(*names):

def _get_engine(uri=SQL_CONNECTION):

def _execute_sql(engine, sql, driver):

def create_database(engine):

def drop_database(engine, current_uri):

def main():

\OpenStack\nova-2014.1\nova\openstack\common\db\sqlalchemy\session.py

class SqliteForeignKeysListener(PoolListener):

    def connect(self, dbapi_con, con_record):

def _raise_if_duplicate_entry_error(integrity_error, engine_name):

    def get_columns_from_uniq_cons_or_name(columns):

def _raise_if_deadlock_error(operational_error, engine_name):

def _wrap_db_error(f):

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

def _synchronous_switch_listener(dbapi_conn, connection_rec):

def _add_regexp_listener(dbapi_con, con_record):

    def regexp(expr, item):

def _thread_yield(dbapi_con, con_record):

def _ping_listener(engine, dbapi_conn, connection_rec, connection_proxy):

def _set_mode_traditional(dbapi_con, connection_rec, connection_proxy):

def _set_session_sql_mode(dbapi_con, connection_rec, connection_proxy, sql_mode=None):

def _is_db_connection_error(args):

def _raise_if_db_connection_lost(error, engine):

def create_engine(sql_connection, sqlite_fk=False, mysql_sql_mode=None, mysql_traditional_mode=False, idle_timeout=3600, connection_debug=0, max_pool_size=None, max_overflow=None, pool_timeout=None, sqlite_synchronous=True, connection_trace=False, max_retries=10, retry_interval=10):

class Query(sqlalchemy.orm.query.Query):

    def soft_delete(self, synchronize_session='evaluate'):

class Session(sqlalchemy.orm.session.Session):

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

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

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

def get_maker(engine, autocommit=True, expire_on_commit=False):

def _patch_mysqldb_with_stacktrace_comments():

    def _do_query(self, q):

class EngineFacade(object):

    def __init__(self, sql_connection, sqlite_fk=False, mysql_sql_mode=None, autocommit=True, expire_on_commit=False, **kwargs):

    def get_engine(self):

    def get_session(self, **kwargs):

\OpenStack\nova-2014.1\nova\openstack\common\db\sqlalchemy\test_base.py

class DbFixture(fixtures.Fixture):

    def _get_uri(self):

    def __init__(self, test):

    def setUp(self):

class DbTestCase(test.BaseTestCase):

    def setUp(self):

def backend_specific(*dialects):

    def wrap(f):

        def ins_wrap(self):

class OpportunisticFixture(DbFixture):

    def _get_uri(self):

class OpportunisticTestCase(DbTestCase):

    def setUp(self):

class MySQLOpportunisticFixture(OpportunisticFixture):

class PostgreSQLOpportunisticFixture(OpportunisticFixture):

class MySQLOpportunisticTestCase(OpportunisticTestCase):

class PostgreSQLOpportunisticTestCase(OpportunisticTestCase):

\OpenStack\nova-2014.1\nova\openstack\common\db\sqlalchemy\test_migrations.py

def _have_mysql(user, passwd, database):

def _have_postgresql(user, passwd, database):

def _set_db_lock(lock_path=None, lock_prefix=None):

 def decorator(f):

class BaseMigrationTestCase(test.BaseTestCase):

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

    def setUp(self):

    def tearDown(self):

    def execute_cmd(self, cmd=None):

    def _reset_pg(self, conn_pieces):

    def _reset_databases(self):

class WalkVersionsMixin(object):

    def _walk_versions(self, engine=None, snake_walk=False, downgrade=True):

    def _migrate_down(self, engine, version, with_data=False):

    def _migrate_up(self, engine, version, with_data=False):

\OpenStack\nova-2014.1\nova\openstack\common\db\sqlalchemy\utils.py

def sanitize_db_url(url):

class InvalidSortKey(Exception):

def paginate_query(query, model, limit, sort_keys, marker=None, sort_dir=None, sort_dirs=None):

def _read_deleted_filter(query, db_model, read_deleted):

def _project_filter(query, db_model, context, project_only):

def model_query(context, model, session, args=None, project_only=False, read_deleted=None):

def get_table(engine, name):

class InsertFromSelect(UpdateBase):

    def __init__(self, table, select):

def visit_insert_from_select(element, compiler, **kw):

class ColumnError(Exception):

    def is_deleted_column_constraint(constraint):

def get_connect_string(backend, database, user=None, passwd=None):

def is_backend_avail(backend, database, user=None, passwd=None):

def get_db_connection_info(conn_pieces):

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

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

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

class EventletBackdoorConfigValueError(Exception):

    def __init__(self, port_range, help_msg, ex):

def _dont_use_this():

def _find_objects(t):

def _print_greenthreads():

def _print_nativethreads():

def _parse_port_range(port_range):

def _listen(host, start_port, end_port, listen_func):

def initialize_if_enabled():

    def displayhook(val):

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

class save_and_reraise_exception(object):

    def __init__(self):

    def __enter__(self):

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

def forever_retry_uncaught_exceptions(infunc):

    def inner_func(*args, **kwargs):

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

def ensure_tree(path):

def read_cached_file(filename, force_reload=False):

def delete_if_exists(path, remove=os.unlink):

def remove_path_on_error(path, remove=delete_if_exists):

def file_open(*args, **kwargs):

def write_to_tempfile(content, path=None, suffix='', prefix='tmp'):

\OpenStack\nova-2014.1\nova\openstack\common\fixture\config.py

class Config(fixtures.Fixture):

    def __init__(self, conf=cfg.CONF):

    def setUp(self):

    def config(self, **kw):

    def _unregister_config_opts(self):

    def register_opt(self, opt, group=None):

    def register_opts(self, opts, group=None):

\OpenStack\nova-2014.1\nova\openstack\common\fixture\lockutils.py

class LockFixture(fixtures.Fixture):

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

    def setUp(self):

\OpenStack\nova-2014.1\nova\openstack\common\fixture\logging.py

def get_logging_handle_error_fixture():

def _handleError(self, record):

\OpenStack\nova-2014.1\nova\openstack\common\fixture\mockpatch.py

class PatchObject(fixtures.Fixture):

    def __init__(self, obj, attr, new=mock.DEFAULT, **kwargs):

    def setUp(self):

class Patch(fixtures.Fixture):

    def __init__(self, obj, new=mock.DEFAULT, **kwargs):

    def setUp(self):

\OpenStack\nova-2014.1\nova\openstack\common\fixture\moxstubout.py

class MoxStubout(fixtures.Fixture):

    def setUp(self):

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

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

def enable_lazy():

def _(msg):

def _log_translation(msg, level):

def install(domain, lazy=False):

class Message(six.text_type):

    def __new__(cls, msgid, msgtext=None, params=None, domain='nova', *args):

    def translate(self, desired_locale=None):

    def _translate_msgid(msgid, domain, desired_locale=None):

    def __mod__(self, other):

    def _sanitize_mod_params(self, other):

    def _trim_dictionary_parameters(self, dict_param):

    def _copy_param(self, param):

    def __add__(self, other):

    def __radd__(self, other):

    def __str__(self):

def get_available_languages(domain):

def translate(obj, desired_locale=None):

def _translate_args(args, desired_locale=None):

class TranslationHandler(handlers.MemoryHandler):

    def __init__(self, locale=None, target=None):

    def setFormatter(self, fmt):

    def emit(self, record):

    def _translate_and_log_record(self, record):

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

class QemuImgInfo(object):

    def __init__(self, cmd_output=None):

    def __str__(self):

    def _canonicalize(self, field):

    def _extract_bytes(self, details):

    def _extract_details(self, root_cmd, root_details, lines_after):

    def _parse(self, cmd_output):

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

def import_class(import_str):

def import_object(import_str, *args, **kwargs):

def import_object_ns(name_space, import_str, *args, **kwargs):

def import_module(import_str):

def try_import(import_str, default=None):

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

def to_primitive(value, convert_instances=False, convert_datetime=True, level=0, max_depth=3):

def dumps(value, default=to_primitive, **kwargs):

def loads(s):

def load(s):

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

class WeakLocal(threading.local):

    def __getattribute__(self, attr):

    def __setattr__(self, attr, value):

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

def set_defaults(lock_path):

class _InterProcessLock(object):

    def __init__(self, name):

    def __enter__(self):

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

    def trylock(self):

    def unlock(self):

class _WindowsLock(_InterProcessLock):

    def trylock(self):

    def unlock(self):

class _PosixLock(_InterProcessLock):

    def trylock(self):

    def unlock(self):

        def foo(self, *args):

        def foo(self, *args):

        def bar(self, *args):

    def wrap(f):

        def inner(*args, **kwargs):

        def bar(self, *args):

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

def _dictify_context(context):

def _get_binary_name():

def _get_log_file_path(binary=None):

def mask_password(message, secret="***"):

class BaseLoggerAdapter(logging.LoggerAdapter):

    def audit(self, msg, *args, **kwargs):

class LazyAdapter(BaseLoggerAdapter):

    def __init__(self, name='unknown', version='unknown'):

    def logger(self):

class ContextAdapter(BaseLoggerAdapter):

    def __init__(self, logger, project_name, version_string):

    def handlers(self):

    def deprecated(self, msg, *args, **kwargs):

    def process(self, msg, kwargs):

class JSONFormatter(logging.Formatter):

    def __init__(self, fmt=None, datefmt=None):

    def formatException(self, ei, strip_newlines=True):

    def format(self, record):

def _create_logging_excepthook(product_name):

    def logging_excepthook(exc_type, value, tb):

class LogConfigError(Exception):

    def __init__(self, log_config, err_msg):

    def __str__(self):

def _load_log_config(log_config_append):

def setup(product_name):

def set_defaults(logging_context_format_string):

def _find_facility_from_conf():

class RFCSysLogHandler(logging.handlers.SysLogHandler):

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

    def format(self, record):

def _setup_logging_from_conf():

def getLogger(name='unknown', version='unknown'):

def getLazyLogger(name='unknown', version='unknown'):

class WritableLogger(object):

    def __init__(self, logger, level=logging.INFO):

    def write(self, msg):

class ContextFormatter(logging.Formatter):

    def format(self, record):

    def formatException(self, exc_info, record=None):

class ColorHandler(logging.StreamHandler):

    def format(self, record):

class DeprecatedConfig(Exception):

    def __init__(self, msg):

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

class LoopingCallDone(Exception):

    def __init__(self, retvalue=True):

class LoopingCallBase(object):

    def __init__(self, f=None, *args, **kw):

    def stop(self):

    def wait(self):

class FixedIntervalLoopingCall(LoopingCallBase):

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

        def _inner():

class DynamicLoopingCall(LoopingCallBase):

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

        def _inner():

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

def get_client(memcached_servers=None):

class Client(object):

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

    def get(self, key):

    def set(self, key, value, time=0, min_compress_len=0):

    def add(self, key, value, time=0, min_compress_len=0):

    def incr(self, key, delta=1):

    def delete(self, key, time=0):

\OpenStack\nova-2014.1\nova\openstack\common\middleware\base.py

class Middleware(object):

    def factory(cls, global_conf, **local_conf):

    def __init__(self, application):

    def process_request(self, req):

    def process_response(self, response):

    def __call__(self, req):

\OpenStack\nova-2014.1\nova\openstack\common\middleware\request_id.py

class RequestIdMiddleware(base.Middleware):

    def process_request(self, req):

    def process_response(self, response):

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

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

def parse_host_port(address, default_port=None):

def urlsplit(url, scheme='', allow_fragments=True):

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

class InvalidPeriodicTaskArg(Exception):

    def decorator(f):

class _PeriodicTasksMeta(type):

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

class PeriodicTasks(object):

    def run_periodic_tasks(self, context, raise_on_error=False):

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

class Rules(dict):

    def load_json(cls, data, default_rule=None):

    def __init__(self, rules=None, default_rule=None):

    def __missing__(self, key):

    def __str__(self):

def set_rules(rules):

def reset():

def check(rule, target, creds, exc=None, *args, **kwargs):

class BaseCheck(object):

    def __str__(self):

    def __call__(self, target, cred):

class FalseCheck(BaseCheck):

    def __str__(self):

    def __call__(self, target, cred):

class TrueCheck(BaseCheck):

    def __str__(self):

    def __call__(self, target, cred):

class Check(BaseCheck):

    def __init__(self, kind, match):

    def __str__(self):

class NotCheck(BaseCheck):

    def __init__(self, rule):

    def __str__(self):

    def __call__(self, target, cred):

class AndCheck(BaseCheck):

    def __init__(self, rules):

    def __str__(self):

    def __call__(self, target, cred):

    def add_check(self, rule):

class OrCheck(BaseCheck):

    def __init__(self, rules):

    def __str__(self):

    def __call__(self, target, cred):

    def add_check(self, rule):

def _parse_check(rule):

def _parse_list_rule(rule):

def _parse_tokenize(rule):

class ParseStateMeta(type):

    def __new__(mcs, name, bases, cls_dict):

def reducer(*tokens):

    def decorator(func):

class ParseState(object):

    def __init__(self):

    def reduce(self):

    def shift(self, tok, value):

    def result(self):

    def _wrap_check(self, _p1, check, _p2):

    def _make_and_expr(self, check1, _and, check2):

    def _extend_and_expr(self, and_expr, _and, check):

    def _make_or_expr(self, check1, _or, check2):

    def _extend_or_expr(self, or_expr, _or, check):

    def _make_not_expr(self, _not, check):

def _parse_text_rule(rule):

def parse_rule(rule):

def register(name, func=None):

    def decorator(func):

class RuleCheck(Check):

    def __call__(self, target, creds):

class RoleCheck(Check):

    def __call__(self, target, creds):

class HttpCheck(Check):

    def __call__(self, target, creds):

class GenericCheck(Check):

    def __call__(self, target, creds):

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

class InvalidArgumentError(Exception):

    def __init__(self, message=None):

class UnknownArgumentError(Exception):

    def __init__(self, message=None):

class ProcessExecutionError(Exception):

    def __init__(self, stdout=None, stderr=None, exit_code=None, cmd=None, description=None):

class NoRootWrapSpecified(Exception):

    def __init__(self, message=None):

def _subprocess_setup():

def execute(*cmd, **kwargs):

def trycmd(*args, **kwargs):

def ssh_execute(ssh, cmd, process_input=None, addl_env=None, check_exit_code=True):

\OpenStack\nova-2014.1\nova\openstack\common\report\generators\conf.py

class ConfigReportGenerator(object):

    def __init__(self, cnf=cfg.CONF):

    def __call__(self):

\OpenStack\nova-2014.1\nova\openstack\common\report\generators\threading.py

class ThreadReportGenerator(object):

    def __call__(self):

class GreenThreadReportGenerator(object):

    def __call__(self):

\OpenStack\nova-2014.1\nova\openstack\common\report\generators\version.py

class PackageReportGenerator(object):

    def __init__(self, version_obj):

    def __call__(self):

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

\OpenStack\nova-2014.1\nova\openstack\common\report\guru_meditation_report.py

class GuruMeditation(object):

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

    def register_section(cls, section_title, generator):

    def setup_autorun(cls, version, signum=None):

    def handle_signal(cls, version, *args):

    def _readd_sections(self):

    def run(self):

class TextGuruMeditation(GuruMeditation, report.TextReport):

    def __init__(self, version_obj):

\OpenStack\nova-2014.1\nova\openstack\common\report\models\base.py

class ReportModel(col.MutableMapping):

    def __init__(self, data=None, attached_view=None):

    def __str__(self):

    def __repr__(self):

    def __getitem__(self, attrname):

    def __setitem__(self, attrname, attrval):

    def __delitem__(self, attrname):

    def __contains__(self, key):

    def __getattr__(self, attrname):

    def __len__(self):

    def __iter__(self):

    def set_current_view_type(self, tp):

\OpenStack\nova-2014.1\nova\openstack\common\report\models\conf.py

class ConfigModel(mwdv.ModelWithDefaultViews):

    def __init__(self, conf_obj):

        def opt_title(optname, co):

\OpenStack\nova-2014.1\nova\openstack\common\report\models\threading.py

class StackTraceModel(mwdv.ModelWithDefaultViews):

    def __init__(self, stack_state):

class ThreadModel(mwdv.ModelWithDefaultViews):

    def __init__(self, thread_id, stack):

class GreenThreadModel(mwdv.ModelWithDefaultViews):

    def __init__(self, stack):

\OpenStack\nova-2014.1\nova\openstack\common\report\models\version.py

class PackageModel(mwdv.ModelWithDefaultViews):

    def __init__(self, vendor, product, version):

\OpenStack\nova-2014.1\nova\openstack\common\report\models\with_default_views.py

class ModelWithDefaultViews(base_model.ReportModel):

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

    def set_current_view_type(self, tp):

    def __getattr__(self, attrname):

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

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

class BasicReport(object):

    def __init__(self):

    def add_section(self, view, generator, index=None):

    def run(self):

class ReportSection(object):

    def __init__(self, view, generator):

    def __str__(self):

class ReportOfType(BasicReport):

    def __init__(self, tp):

    def add_section(self, view, generator, index=None):

        def with_type(gen):

class TextReport(ReportOfType):

    def __init__(self, name):

    def add_section(self, heading, generator, index=None):

\OpenStack\nova-2014.1\nova\openstack\common\report\utils.py

class StringWithAttrs(str):

def _find_objects(t):

\OpenStack\nova-2014.1\nova\openstack\common\report\views\jinja_view.py

class JinjaView(object):

    def __init__(self, path=None, text=None):

    def __call__(self, model):

    def template(self):

    def _gettext(self):

    def _settext(self, textval):

\OpenStack\nova-2014.1\nova\openstack\common\report\views\json\generic.py

class BasicKeyValueView(object):

    def __call__(self, model):

class KeyValueView(object):

    def __call__(self, model):

\OpenStack\nova-2014.1\nova\openstack\common\report\views\json\__init__.py

\OpenStack\nova-2014.1\nova\openstack\common\report\views\text\generic.py

class MultiView(object):

    def __call__(self, model):

class BasicKeyValueView(object):

    def __call__(self, model):

class KeyValueView(object):

    def __init__(self, indent_str=' ', key_sep=' = ', dict_sep=' = ', list_sep=' = ', anon_dict='[dict]', before_dict=None, before_list=None):

    def __call__(self, model):

        def serialize(root, rootkey, indent):

class TableView(object):

    def __init__(self, column_names, column_values, table_prop_name):

    def __call__(self, model):

\OpenStack\nova-2014.1\nova\openstack\common\report\views\text\header.py

class HeaderView(object):

    def __init__(self, header):

    def __call__(self, model):

class TitledView(HeaderView):

    def __init__(self, title):

\OpenStack\nova-2014.1\nova\openstack\common\report\views\text\threading.py

class StackTraceView(jv.JinjaView):

class GreenThreadView(object):

    def __call__(self, model):

class ThreadView(object):

    def __call__(self, model):

\OpenStack\nova-2014.1\nova\openstack\common\report\views\text\__init__.py

\OpenStack\nova-2014.1\nova\openstack\common\report\views\xml\generic.py

class KeyValueView(object):

    def __init__(self, wrapper_name="model"):

    def __call__(self, model):

        def serialize(rootmodel, rootkeyname):

\OpenStack\nova-2014.1\nova\openstack\common\report\views\xml\__init__.py

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

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

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

def _sighup_supported():

def _is_daemon():

def _is_sighup_and_daemon(signo):

def _signo_to_signame(signo):

def _set_signals_handler(handler):

class Launcher(object):

    def __init__(self):

    def launch_service(self, service):

    def stop(self):

    def wait(self):

    def restart(self):

class SignalExit(SystemExit):

    def __init__(self, signo, exccode=1):

class ServiceLauncher(Launcher):

    def _handle_signal(self, signo, frame):

    def handle_signal(self):

    def _wait_for_exit_or_signal(self, ready_callback=None):

    def wait(self, ready_callback=None):

class ServiceWrapper(object):

    def __init__(self, service, workers):

class ProcessLauncher(object):

    def __init__(self):

    def handle_signal(self):

    def _handle_signal(self, signo, frame):

    def _pipe_watcher(self):

    def _child_process_handle_signal(self):

        def _sigterm(*args):

        def _sighup(*args):

    def _child_wait_for_exit_or_signal(self, launcher):

    def _child_process(self, service):

    def _start_child(self, wrap):

    def launch_service(self, service, workers=1):

    def _wait_child(self):

    def _respawn_children(self):

    def wait(self):

class Service(object):

    def __init__(self, threads=1000):

    def reset(self):

    def start(self):

    def stop(self):

    def wait(self):

class Services(object):

    def __init__(self):

    def add(self, service):

    def stop(self):

    def wait(self):

    def restart(self):

    def run_service(service, done):

def launch(service, workers=None):

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

def is_enabled():

def wrap(sock):

def validate_ssl_version(version):

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

def int_from_bool_as_string(subject):

def bool_from_string(subject, strict=False):

def safe_decode(text, incoming=None, errors='strict'):

def safe_encode(text, incoming=None, encoding='utf-8', errors='strict'):

def to_bytes(text, default=0):

def to_slug(value, incoming=None, errors="strict"):

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

def _thread_done(gt, *args, **kwargs):

class Thread(object):

    def __init__(self, thread, group):

    def stop(self):

    def wait(self):

class ThreadGroup(object):

    def __init__(self, thread_pool_size=10):

    def add_dynamic_timer(self, callback, initial_delay=None, periodic_interval_max=None, *args, **kwargs):

    def add_timer(self, interval, callback, initial_delay=None, *args, **kwargs):

    def add_thread(self, callback, *args, **kwargs):

    def thread_done(self, thread):

    def stop(self):

    def wait(self):

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

def isotime(at=None, subsecond=False):

def parse_isotime(timestr):

def strtime(at=None, fmt=PERFECT_TIME_FORMAT):

def parse_strtime(timestr, fmt=PERFECT_TIME_FORMAT):

OpenStack Index

Previous

Next