OpenStack Study: cinder

OpenStack Index

class InvalidSnapshot(Invalid):

class InvalidVolumeAttachMode(Invalid):

class VolumeAttached(Invalid):

class SfJsonEncodeFailure(CinderException):

class InvalidResults(Invalid):

class InvalidInput(Invalid):

class InvalidVolumeType(Invalid):

class InvalidVolume(Invalid):

class InvalidContentType(Invalid):

class InvalidHost(Invalid):

class InvalidParameterValue(Invalid):

class InvalidAuthKey(Invalid):

class InvalidConfigurationValue(Invalid):

class ServiceUnavailable(Invalid):

class ImageUnacceptable(Invalid):

class DeviceUnavailable(Invalid):

class InvalidUUID(Invalid):

class NotFound(CinderException):

class VolumeNotFound(NotFound):

class VolumeMetadataNotFound(NotFound):

class VolumeAdminMetadataNotFound(NotFound):

class InvalidVolumeMetadata(Invalid):

class InvalidVolumeMetadataSize(Invalid):

class SnapshotMetadataNotFound(NotFound):

class VolumeTypeNotFound(NotFound):

class VolumeTypeNotFoundByName(VolumeTypeNotFound):

class VolumeTypeExtraSpecsNotFound(NotFound):

class VolumeTypeInUse(CinderException):

class SnapshotNotFound(NotFound):

class VolumeIsBusy(CinderException):

class SnapshotIsBusy(CinderException):

class ISCSITargetNotFoundForVolume(NotFound):

class InvalidImageRef(Invalid):

class ImageNotFound(NotFound):

class ServiceNotFound(NotFound):

class HostNotFound(NotFound):

class SchedulerHostFilterNotFound(NotFound):

class SchedulerHostWeigherNotFound(NotFound):

class HostBinaryNotFound(NotFound):

class InvalidReservationExpiration(Invalid):

class InvalidQuotaValue(Invalid):

class QuotaNotFound(NotFound):

class QuotaResourceUnknown(QuotaNotFound):

class ProjectQuotaNotFound(QuotaNotFound):

class QuotaClassNotFound(QuotaNotFound):

class QuotaUsageNotFound(QuotaNotFound):

class ReservationNotFound(QuotaNotFound):

class OverQuota(CinderException):

class FileNotFound(NotFound):

class Duplicate(CinderException):

class VolumeTypeExists(Duplicate):

class VolumeTypeEncryptionExists(Invalid):

class VolumeTypeEncryptionNotFound(NotFound):

class MalformedRequestBody(CinderException):

class ConfigNotFound(NotFound):

class ParameterNotFound(NotFound):

class PasteAppNotFound(NotFound):

class NoValidHost(CinderException):

class NoMoreTargets(CinderException):

class QuotaError(CinderException):

class VolumeSizeExceedsAvailableQuota(QuotaError):

class VolumeLimitExceeded(QuotaError):

class SnapshotLimitExceeded(QuotaError):

class DuplicateSfVolumeNames(Duplicate):

class VolumeTypeCreateFailed(CinderException):

class UnknownCmd(VolumeDriverException):

class MalformedResponse(VolumeDriverException):

class FailedCmdWithDump(VolumeDriverException):

class GlanceMetadataExists(Invalid):

class GlanceMetadataNotFound(NotFound):

class ExportFailure(Invalid):

class MetadataCreateFailure(Invalid):

class MetadataUpdateFailure(Invalid):

class MetadataCopyFailure(Invalid):

class ImageCopyFailure(Invalid):

class BackupInvalidCephArgs(BackupDriverException):

class BackupOperationError(Invalid):

class BackupMetadataUnsupportedVersion(BackupDriverException):

class VolumeMetadataBackupExists(BackupDriverException):

class BackupRBDOperationFailed(BackupDriverException):

class BackupNotFound(NotFound):

class BackupFailedToGetVolumeBackend(NotFound):

class InvalidBackup(Invalid):

class SwiftConnectionFailed(BackupDriverException):

class TransferNotFound(NotFound):

class VolumeMigrationFailed(CinderException):

class SSHInjectionThreat(CinderException):

class QoSSpecsExists(Duplicate):

class QoSSpecsCreateFailed(CinderException):

class QoSSpecsUpdateFailed(CinderException):

class QoSSpecsNotFound(NotFound):

class QoSSpecsAssociateFailed(CinderException):

class QoSSpecsDisassociateFailed(CinderException):

class QoSSpecsKeyNotFound(NotFound):

class InvalidQoSSpecs(Invalid):

class QoSSpecsInUse(CinderException):

class KeyManagerError(CinderException):

class ManageExistingInvalidReference(CinderException):

class ManageExistingVolumeTypeMismatch(CinderException):

class CoraidException(VolumeDriverException):

class CoraidJsonEncodeFailure(CoraidException):

class CoraidESMBadCredentials(CoraidException):

class CoraidESMReloginFailed(CoraidException):

class CoraidESMBadGroup(CoraidException):

class CoraidESMConfigureError(CoraidException):

class CoraidESMNotAvailable(CoraidException):

class ZadaraException(VolumeDriverException):

class ZadaraServerCreateFailure(ZadaraException):

class ZadaraServerNotFound(ZadaraException):

class ZadaraVPSANoActiveController(ZadaraException):

class ZadaraAttachmentsNotFound(ZadaraException):

class ZadaraInvalidAttachmentInfo(ZadaraException):

class BadHTTPResponseStatus(ZadaraException):

class SolidFireAPIException(VolumeBackendAPIException):

class SolidFireDriverException(VolumeDriverException):

class SolidFireAPIDataException(SolidFireAPIException):

class SolidFireAccountNotFound(SolidFireDriverException):

class Invalid3PARDomain(VolumeDriverException):

class NfsException(VolumeDriverException):

class NfsNoSharesMounted(VolumeDriverException):

class NfsNoSuitableShareFound(VolumeDriverException):

class GlusterfsException(VolumeDriverException):

class GlusterfsNoSharesMounted(VolumeDriverException):

class GlusterfsNoSuitableShareFound(VolumeDriverException):

class RemoveExportException(VolumeDriverException):

class HPMSAVolumeDriverException(VolumeDriverException):

class HPMSAInvalidVDisk(HPMSAVolumeDriverException):

class HPMSAConnectionError(HPMSAVolumeDriverException):

class HPMSANotEnoughSpace(HPMSAVolumeDriverException):

class ZoneManagerException(CinderException):

class FCZoneDriverException(CinderException):

class FCSanLookupServiceException(CinderException):

class BrocadeZoningCliException(CinderException):

class NetAppDriverException(VolumeDriverException):

\OpenStack\cinder-2014.1\cinder\flow_utils.py

def _make_task_name(cls, addons=None):

class CinderTask(task.Task):

    def __init__(self, addons=None, **kwargs):

\OpenStack\cinder-2014.1\cinder\image\glance.py

def _parse_image_ref(image_href):

def _create_glance_client(context, netloc, use_ssl, version=CONF.glance_api_version):

def get_api_servers():

class GlanceClientWrapper(object):

    def __init__(self, context=None, netloc=None, use_ssl=False, version=None):

    def _create_static_client(self, context, netloc, use_ssl, version):

    def _create_onetime_client(self, context, version):

    def call(self, context, method, *args, **kwargs):

class GlanceImageService(object):

    def __init__(self, client=None):

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

    def _extract_query_params(self, params):

    def show(self, context, image_id):

    def get_location(self, context, image_id):

    def download(self, context, image_id, data=None):

    def create(self, context, image_meta, data=None):

    def update(self, context, image_id, image_meta, data=None, purge_props=True):

    def delete(self, context, image_id):

    def _translate_to_glance(image_meta):

    def _translate_from_glance(image):

    def _is_image_available(context, image):

def _convert_timestamps_to_datetimes(image_meta):

def _json_loads(properties, attr):

def _json_dumps(properties, attr):

def _convert(method, metadata):

def _convert_from_string(metadata):

def _convert_to_string(metadata):

def _extract_attributes(image):

def _remove_read_only(image_meta):

def _reraise_translated_image_exception(image_id):

def _reraise_translated_exception():

def _translate_image_exception(image_id, exc_value):

def _translate_plain_exception(exc_value):

def get_remote_image_service(context, image_href):

def get_default_image_service():

\OpenStack\cinder-2014.1\cinder\image\image_utils.py

def qemu_img_info(path):

def convert_image(source, dest, out_format):

def resize_image(source, size, run_as_root=False):

def fetch(context, image_service, image_id, path, _user_id, _project_id):

def fetch_verify_image(context, image_service, image_id, dest, user_id=None, project_id=None, size=None):

def fetch_to_vhd(context, image_service, image_id, dest, blocksize, user_id=None, project_id=None):

def fetch_to_raw(context, image_service, image_id, dest, blocksize, user_id=None, project_id=None, size=None):

def fetch_to_volume_format(context, image_service, image_id, dest, volume_format, blocksize, user_id=None, project_id=None, size=None):

def upload_volume(context, image_service, image_meta, volume_path, volume_format='raw'):

def is_xenserver_image(context, image_service, image_id):

def is_xenserver_format(image_meta):

def file_exist(fpath):

def set_vhd_parent(vhd_path, parentpath):

def extract_targz(archive_name, target):

def fix_vhd_chain(vhd_chain):

def get_vhd_size(vhd_path):

def resize_vhd(vhd_path, size, journal):

def coalesce_vhd(vhd_path):

def create_temporary_file():

def rename_file(src, dst):

def temporary_file():

def temporary_dir():

def coalesce_chain(vhd_chain):

def discover_vhd_chain(directory):

def replace_xenserver_image_with_coalesced_vhd(image_file):

\OpenStack\cinder-2014.1\cinder\image\__init__.py

class ConfKeyManager(key_mgr.KeyManager):

    def __init__(self):

    def _generate_key(self, **kwargs):

    def _generate_hex_key(self, **kwargs):

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

    def store_key(self, ctxt, key, **kwargs):

    def copy_key(self, ctxt, key_id, **kwargs):

    def get_key(self, ctxt, key_id, **kwargs):

    def delete_key(self, ctxt, key_id, **kwargs):

\OpenStack\cinder-2014.1\cinder\keymgr\key.py

class Key(object):

    def get_algorithm(self):

    def get_format(self):

    def get_encoded(self):

class SymmetricKey(Key):

    def __init__(self, alg, key):

    def get_algorithm(self):

    def get_format(self):

    def get_encoded(self):

    def __eq__(self, other):

    def __ne__(self, other):

\OpenStack\cinder-2014.1\cinder\keymgr\key_mgr.py

class KeyManager(object):

    def create_key(self, ctxt, algorithm='AES', length=256, expiration=None, **kwargs):

    def store_key(self, ctxt, key, expiration=None, **kwargs):

    def copy_key(self, ctxt, key_id, **kwargs):

    def get_key(self, ctxt, key_id, **kwargs):

    def delete_key(self, ctxt, key_id, **kwargs):

\OpenStack\cinder-2014.1\cinder\keymgr\not_implemented_key_mgr.py

class NotImplementedKeyManager(key_mgr.KeyManager):

    def create_key(self, ctxt, algorithm='AES', length=256, expiration=None, **kwargs):

    def store_key(self, ctxt, key, expiration=None, **kwargs):

    def copy_key(self, ctxt, key_id, **kwargs):

    def get_key(self, ctxt, key_id, **kwargs):

    def delete_key(self, ctxt, key_id, **kwargs):

\OpenStack\cinder-2014.1\cinder\keymgr\__init__.py

def API():

\OpenStack\cinder-2014.1\cinder\manager.py

class Manager(base.Base, periodic_task.PeriodicTasks):

    def __init__(self, host=None, db_driver=None):

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

    def init_host(self):

    def service_version(self, context):

    def service_config(self, context):

class SchedulerDependentManager(Manager):

    def __init__(self, host=None, db_driver=None, service_name='undefined'):

    def update_service_capabilities(self, capabilities):

    def _publish_service_capabilities(self, context):

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

def raise_extension_exception(extmanager, ep, err):

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\cinder-2014.1\cinder\openstack\common\config\__init__.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="no"):

def get_context_from_function_and_args(function, args, kwargs):

\OpenStack\cinder-2014.1\cinder\openstack\common\crypto\utils.py

class CryptoutilsException(Exception):

class CipherBlockLengthTooBig(CryptoutilsException):

    def __init__(self, requested, permitted):

class HKDFOutputLengthTooLong(CryptoutilsException):

    def __init__(self, requested, permitted):

class HKDF(object):

    def __init__(self, hashtype='SHA256'):

    def extract(self, ikm, salt=None):

    def expand(self, prk, info, length):

class SymmetricCrypto(object):

    def __init__(self, enctype='AES', hashtype='SHA256'):

    def new_key(self, size):

    def encrypt(self, key, msg, b64encode=True):

    def decrypt(self, key, msg, b64decode=True):

    def sign(self, key, msg, b64encode=True):

\OpenStack\cinder-2014.1\cinder\openstack\common\crypto\__init__.py

class DBAPI(object):

    def __init__(self, backend_mapping=None):

    def __get_backend(self):

    def __getattr__(self, key):

        def tpool_wrapper(*args, **kwargs):

\OpenStack\cinder-2014.1\cinder\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):

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

class ModelBase(object):

    def save(self, session=None):

    def __setitem__(self, key, value):

    def __getitem__(self, key):

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

    def __iter__(self):

    def next(self):

    def update(self, values):

    def iteritems(self):

class TimestampMixin(object):

class SoftDeleteMixin(object):

    def soft_delete(self, session=None):

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

def set_defaults(sql_connection, sqlite_db):

def cleanup():

class SqliteForeignKeysListener(PoolListener):

    def connect(self, dbapi_con, con_record):

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

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(*args, **kwargs):

def get_engine(sqlite_fk=False):

def _synchronous_switch_listener(dbapi_conn, connection_rec):

def _add_regexp_listener(dbapi_con, con_record):

    def regexp(expr, item):

def _greenthread_yield(dbapi_con, con_record):

def _ping_listener(dbapi_conn, connection_rec, connection_proxy):

def _is_db_connection_error(args):

def create_engine(sql_connection, sqlite_fk=False):

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

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

class InvalidSortKey(Exception):

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

\OpenStack\cinder-2014.1\cinder\openstack\common\db\sqlalchemy\__init__.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\cinder-2014.1\cinder\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\cinder-2014.1\cinder\openstack\common\fileutils.py

def ensure_tree(path):

def read_cached_file(filename, force_reload=False):

def delete_if_exists(path):

def remove_path_on_error(path):

def file_open(*args, **kwargs):

\OpenStack\cinder-2014.1\cinder\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='cinder', *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 _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\cinder-2014.1\cinder\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\cinder-2014.1\cinder\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 import_versioned_module(version, submodule=None):

def try_import(import_str, default=None):

\OpenStack\cinder-2014.1\cinder\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\cinder-2014.1\cinder\openstack\common\local.py

class WeakLocal(threading.local):

    def __getattribute__(self, attr):

    def __setattr__(self, attr, value):

\OpenStack\cinder-2014.1\cinder\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\cinder-2014.1\cinder\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, version='unknown'):

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(project, version):

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 __init__(self, *args, **kwargs):

    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\cinder-2014.1\cinder\openstack\common\log_handler.py

class PublishErrorsHandler(logging.Handler):

    def emit(self, record):

\OpenStack\cinder-2014.1\cinder\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\cinder-2014.1\cinder\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\cinder-2014.1\cinder\openstack\common\middleware\request_id.py

class RequestIdMiddleware(base.Middleware):

    def process_request(self, req):

    def process_response(self, response):

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

def parse_host_port(address, default_port=None):

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

\OpenStack\cinder-2014.1\cinder\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\cinder-2014.1\cinder\openstack\common\policy.py

def set_brain(brain):

def reset():

def enforce(match_list, target_dict, credentials_dict, exc=None, *args, **kwargs):

class Brain(object):

    def _register(cls, name, func):

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

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

    def add_rule(self, key, match):

    def _check(self, match, target_dict, cred_dict):

    def check(self, match_list, target_dict, cred_dict):

class HttpBrain(Brain):

    def decorator(func):

def _check_rule(brain, match_kind, match, target_dict, cred_dict):

def _check_role(brain, match_kind, match, target_dict, cred_dict):

def _check_http(brain, match_kind, match, target_dict, cred_dict):

def _check_generic(brain, match_kind, match, target_dict, cred_dict):

\OpenStack\cinder-2014.1\cinder\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\cinder-2014.1\cinder\openstack\common\request_utils.py

def link_request_ids(context, source_id, target_id=None, stage=None, target_name=None, notifier=None):

\OpenStack\cinder-2014.1\cinder\openstack\common\scheduler\base_filter.py

class BaseFilter(object):

    def _filter_one(self, obj, filter_properties):

    def filter_all(self, filter_obj_list, filter_properties):

class BaseFilterHandler(base_handler.BaseHandler):

    def get_filtered_objects(self, filter_classes, objs, filter_properties):

\OpenStack\cinder-2014.1\cinder\openstack\common\scheduler\base_handler.py

class BaseHandler(object):

    def __init__(self, modifier_class_type, modifier_namespace):

    def _is_correct_class(self, cls):

    def get_all_classes(self):

\OpenStack\cinder-2014.1\cinder\openstack\common\scheduler\base_weight.py

class WeighedObject(object):

    def __init__(self, obj, weight):

    def __repr__(self):

class BaseWeigher(object):

    def _weight_multiplier(self):

    def _weigh_object(self, obj, weight_properties):

    def weigh_objects(self, weighed_obj_list, weight_properties):

class BaseWeightHandler(base_handler.BaseHandler):

    def get_weighed_objects(self, weigher_classes, obj_list, weighing_properties):

\OpenStack\cinder-2014.1\cinder\openstack\common\scheduler\filters\availability_zone_filter.py

class AvailabilityZoneFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\cinder-2014.1\cinder\openstack\common\scheduler\filters\capabilities_filter.py

class CapabilitiesFilter(filters.BaseHostFilter):

    def _satisfies_extra_specs(self, capabilities, resource_type):

    def host_passes(self, host_state, filter_properties):

\OpenStack\cinder-2014.1\cinder\openstack\common\scheduler\filters\extra_specs_ops.py

def match(value, req):

\OpenStack\cinder-2014.1\cinder\openstack\common\scheduler\filters\ignore_attempted_hosts_filter.py

class IgnoreAttemptedHostsFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

\OpenStack\cinder-2014.1\cinder\openstack\common\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\cinder-2014.1\cinder\openstack\common\scheduler\filters\__init__.py

class BaseHostFilter(base_filter.BaseFilter):

    def _filter_one(self, obj, filter_properties):

    def host_passes(self, host_state, filter_properties):

class HostFilterHandler(base_filter.BaseFilterHandler):

    def __init__(self, namespace):

\OpenStack\cinder-2014.1\cinder\openstack\common\scheduler\weights\__init__.py

class WeighedHost(base_weight.WeighedObject):

    def to_dict(self):

    def __repr__(self):

class BaseHostWeigher(base_weight.BaseWeigher):

class HostWeightHandler(base_weight.BaseWeightHandler):

    def __init__(self, namespace):

\OpenStack\cinder-2014.1\cinder\openstack\common\scheduler\__init__.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, wait_interval=0.01):

    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\cinder-2014.1\cinder\openstack\common\sslutils.py

def is_enabled():

def wrap(sock):

def validate_ssl_version(version):

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

def int_from_bool_as_string(subject):

def bool_from_string(subject, strict=False, default=False):

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

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

def string_to_bytes(text, unit_system='IEC', return_int=False):

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

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

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

class Thread(object):

    def __init__(self, thread, group):

    def stop(self):

    def wait(self):

    def link(self, func, *args, **kwargs):

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\cinder-2014.1\cinder\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):

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\cinder-2014.1\cinder\openstack\common\uuidutils.py

def generate_uuid():

def is_uuid_like(val):

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

class deprecated(object):

    def __init__(self, as_of, in_favor_of=None, remove_in=2, what=None):

    def __call__(self, func):

        def wrapped(*args, **kwargs):

    def _get_safe_to_remove_release(self, release):

    def _build_message(self):

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

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

def reset():

def init():

def _set_brain(data):

def enforce_action(context, action):

def enforce(context, action, target):

def check_is_admin(roles):

\OpenStack\cinder-2014.1\cinder\quota.py

class DbQuotaDriver(object):

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

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

    def get_default(self, context, resource):

    def get_defaults(self, context, resources):

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

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

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

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

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

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

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

    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 VolumeTypeResource(ReservableResource):

    def __init__(self, part_name, volume_type):

class QuotaEngine(object):

    def __init__(self, quota_driver_class=None):

    def __contains__(self, resource):

    def register_resource(self, resource):

    def register_resources(self, resources):

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

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

    def get_default(self, context, resource):

    def get_defaults(self, context):

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

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

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

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

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

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

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

    def destroy_all_by_project(self, context, project_id):

    def expire(self, context):

    def add_volume_type_opts(self, context, opts, volume_type_id):

    def resource_names(self):

    def resources(self):

class VolumeTypeQuotaEngine(QuotaEngine):

    def resources(self):

    def register_resource(self, resource):

    def register_resources(self, resources):

\OpenStack\cinder-2014.1\cinder\quota_utils.py

def get_volume_type_reservation(ctxt, volume, type_id):

\OpenStack\cinder-2014.1\cinder\rpc.py

def init(conf):

def initialized():

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\cinder-2014.1\cinder\scheduler\driver.py

def volume_update_db(context, volume_id, host):

class Scheduler(object):

    def __init__(self):

    def update_service_capabilities(self, service_name, host, capabilities):

    def host_passes_filters(self, context, volume_id, host, filter_properties):

    def find_retype_host(self, context, request_spec, filter_properties={}, migration_policy='never'):

    def schedule(self, context, topic, method, *_args, **_kwargs):

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

\OpenStack\cinder-2014.1\cinder\scheduler\filters\capacity_filter.py

class CapacityFilter(filters.BaseHostFilter):

    def host_passes(self, host_state, filter_properties):

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

class FilterScheduler(driver.Scheduler):

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

    def schedule(self, context, topic, method, *args, **kwargs):

    def _get_configuration_options(self):

    def populate_filter_properties(self, request_spec, filter_properties):

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

    def host_passes_filters(self, context, host, request_spec, filter_properties):

    def find_retype_host(self, context, request_spec, filter_properties={}, migration_policy='never'):

    def _post_select_populate_filter_properties(self, filter_properties, host_state):

    def _add_retry_host(self, filter_properties, host):

    def _max_attempts(self):

    def _log_volume_error(self, volume_id, retry):

    def _populate_retry(self, filter_properties, properties):

    def _get_weighted_candidates(self, context, request_spec, filter_properties=None):

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

    def _choose_top_host(self, weighed_hosts, request_spec):

\OpenStack\cinder-2014.1\cinder\scheduler\flows\create_volume.py

class ExtractSchedulerSpecTask(flow_utils.CinderTask):

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

    def _populate_request_spec(self, context, volume_id, snapshot_id, image_id):

    def execute(self, context, request_spec, volume_id, snapshot_id, image_id):

def get_flow(context, db, driver, request_spec=None, filter_properties=None, volume_id=None, snapshot_id=None, image_id=None):

    def schedule_create_volume(context, request_spec, filter_properties):

        def _log_failure(cause):

        def _notify_failure(cause):

\OpenStack\cinder-2014.1\cinder\scheduler\flows\__init__.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, capabilities=None, service=None):

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

    def update_from_volume_capability(self, capability):

    def consume_from_volume(self, volume):

    def __repr__(self):

class HostManager(object):

    def __init__(self):

    def _choose_host_filters(self, filter_cls_names):

    def _choose_host_weighers(self, weight_cls_names):

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

    def get_weighed_hosts(self, hosts, weight_properties, weigher_class_names=None):

    def update_service_capabilities(self, service_name, host, capabilities):

    def get_all_host_states(self, context):

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

class SchedulerManager(manager.Manager):

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

    def init_host(self):

    def update_service_capabilities(self, context, service_name=None, host=None, capabilities=None, **kwargs):

    def create_volume(self, context, topic, volume_id, snapshot_id=None, image_id=None, request_spec=None, filter_properties=None):

    def request_service_capabilities(self, context):

    def migrate_volume_to_host(self, context, topic, volume_id, host, force_host_copy, request_spec, filter_properties=None):

        def _migrate_volume_set_error(self, context, ex, request_spec):

    def retype(self, context, topic, volume_id, request_spec, filter_properties=None):

        def _retype_volume_set_error(self, context, ex, request_spec, volume_ref, msg, reservations):

OpenStack Index

• index_cinder.htm
• index_cinder_1.htm
• index_cinder_10.htm
• index_cinder_11.htm
• index_cinder_12.htm
• index_cinder_2.htm
• index_cinder_3.htm
• index_cinder_4.htm
• index_cinder_5.htm
• index_cinder_6.htm
• index_cinder_7.htm
• index_cinder_8.htm
• index_cinder_9.htm