@

Home 

OpenStack Study: glance

OpenStack Index

Next

\OpenStack\glance-2014.1\glance\api\authorization.py

def is_image_mutable(context, image):

def proxy_image(context, image):

def is_member_mutable(context, member):

def proxy_member(context, member):

def is_task_mutable(context, task):

def proxy_task(context, task):

def proxy_task_details(context, task, task_details):

class ImageRepoProxy(glance.domain.proxy.Repo):

    def __init__(self, image_repo, context):

    def get(self, image_id):

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

class ImageMemberRepoProxy(glance.domain.proxy.Repo):

    def __init__(self, member_repo, image, context):

    def get(self, member_id):

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

    def remove(self, image_member):

    def add(self, image_member):

    def save(self, image_member):

class ImageFactoryProxy(glance.domain.proxy.ImageFactory):

    def __init__(self, image_factory, context):

    def new_image(self, **kwargs):

class ImageMemberFactoryProxy(object):

    def __init__(self, image_member_factory, context):

    def new_image_member(self, image, member_id):

def _immutable_attr(target, attr, proxy=None):

    def get_attr(self):

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

class ImmutableLocations(list):

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

    def __deepcopy__(self, memo):

class ImmutableProperties(dict):

    def forbidden_key(self, key, *args, **kwargs):

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

class ImmutableTags(set):

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

class ImmutableImageProxy(object):

    def __init__(self, base, context):

    def delete(self):

    def get_member_repo(self):

    def get_data(self):

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

class ImmutableMemberProxy(object):

    def __init__(self, base):

class ImmutableTaskProxy(object):

    def __init__(self, base):

    def run(self, executor):

    def begin_processing(self):

    def succeed(self, result):

    def fail(self, message):

class ImmutableTaskDetailsProxy(object):

    def __init__(self, base):

class ImageProxy(glance.domain.proxy.Image):

    def __init__(self, image, context):

    def get_member_repo(self, **kwargs):

class TaskProxy(glance.domain.proxy.Task):

    def __init__(self, task):

class TaskDetailsProxy(glance.domain.proxy.TaskDetails):

    def __init__(self, task_details):

class TaskFactoryProxy(glance.domain.proxy.TaskFactory):

    def __init__(self, task_factory, context):

    def new_task(self, **kwargs):

class TaskRepoProxy(glance.domain.proxy.TaskRepo):

    def __init__(self, task_repo, context):

    def get_task_and_details(self, task_id):

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

\OpenStack\glance-2014.1\glance\api\cached_images.py

class Controller(controller.BaseController):

    def __init__(self):

    def _enforce(self, req):

    def get_cached_images(self, req):

    def delete_cached_image(self, req, image_id):

    def delete_cached_images(self, req):

    def get_queued_images(self, req):

    def queue_image(self, req, image_id):

    def delete_queued_image(self, req, image_id):

    def delete_queued_images(self, req):

class CachedImageDeserializer(wsgi.JSONRequestDeserializer):

class CachedImageSerializer(wsgi.JSONResponseSerializer):

def create_resource():

\OpenStack\glance-2014.1\glance\api\common.py

def size_checked_iter(response, image_meta, expected_size, image_iter, notifier):

def image_send_notification(bytes_written, expected_size, image_meta, request, notifier):

def get_remaining_quota(context, db_api, image_id=None):

def check_quota(context, image_size, db_api, image_id=None):

\OpenStack\glance-2014.1\glance\api\middleware\cache.py

class CacheFilter(wsgi.Middleware):

    def __init__(self, app):

    def _verify_metadata(self, image_meta):

    def _match_request(request):

    def _enforce(self, req, action):

    def process_request(self, request):

    def _stash_request_info(request, image_id, method):

    def _fetch_request_info(request):

    def _process_v1_request(self, request, image_id, image_iterator):

    def _process_v2_request(self, request, image_id, image_iterator):

    def process_response(self, resp):

    def _process_DELETE_response(self, resp, image_id):

    def _process_GET_response(self, resp, image_id):

    def get_status_code(self, response):

    def get_from_cache(self, image_id):

\OpenStack\glance-2014.1\glance\api\middleware\cache_manage.py

class CacheManageFilter(wsgi.Middleware):

    def __init__(self, app):

    def process_request(self, request):

\OpenStack\glance-2014.1\glance\api\middleware\context.py

class BaseContextMiddleware(wsgi.Middleware):

    def process_response(self, resp):

class ContextMiddleware(BaseContextMiddleware):

    def __init__(self, app):

    def process_request(self, req):

    def _get_anonymous_context(self):

    def _get_authenticated_context(self, req):

class UnauthenticatedContextMiddleware(BaseContextMiddleware):

    def process_request(self, req):

\OpenStack\glance-2014.1\glance\api\middleware\gzip.py

class GzipMiddleware(wsgi.Middleware):

    def __init__(self, app):

    def process_response(self, response):

\OpenStack\glance-2014.1\glance\api\middleware\version_negotiation.py

class VersionNegotiationFilter(wsgi.Middleware):

    def __init__(self, app):

    def process_request(self, req):

    def _match_version_string(self, subject):

    def _pop_path_info(self, req):

\OpenStack\glance-2014.1\glance\api\middleware\__init__.py

\OpenStack\glance-2014.1\glance\api\policy.py

class Enforcer(object):

    def __init__(self):

    def set_rules(self, rules):

    def add_rules(self, rules):

    def load_rules(self):

    def _find_policy_file():

    def _read_policy_file(self):

    def _check(self, context, rule, target, *args, **kwargs):

    def enforce(self, context, action, target):

    def check(self, context, action, target):

    def check_is_admin(self, context):

class ImageRepoProxy(glance.domain.proxy.Repo):

    def __init__(self, image_repo, context, policy):

    def get(self, image_id):

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

    def save(self, image):

    def add(self, image):

class ImageProxy(glance.domain.proxy.Image):

    def __init__(self, image, context, policy):

    def visibility(self):

    def visibility(self, value):

    def locations(self):

    def locations(self, value):

    def delete(self):

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

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

    def get_member_repo(self, **kwargs):

class ImageFactoryProxy(glance.domain.proxy.ImageFactory):

    def __init__(self, image_factory, context, policy):

    def new_image(self, **kwargs):

class ImageMemberFactoryProxy(glance.domain.proxy.ImageMembershipFactory):

    def __init__(self, member_factory, context, policy):

class ImageMemberRepoProxy(glance.domain.proxy.Repo):

    def __init__(self, member_repo, context, policy):

    def add(self, member):

    def get(self, member_id):

    def save(self, member):

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

    def remove(self, member):

class ImageLocationsProxy(object):

    def __init__(self, locations, context, policy):

    def __copy__(self):

    def __deepcopy__(self, memo):

    def _get_checker(action, func_name):

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

class TaskProxy(glance.domain.proxy.Task):

    def __init__(self, task, context, policy):

    def run(self, executor):

class TaskDetailsProxy(glance.domain.proxy.TaskDetails):

    def __init__(self, task_details, context, policy):

class TaskRepoProxy(glance.domain.proxy.TaskRepo):

    def __init__(self, task_repo, context, task_policy):

    def get_task_and_details(self, task_id):

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

    def add(self, task, task_details=None):

    def save(self, task, task_details=None):

class TaskFactoryProxy(glance.domain.proxy.TaskFactory):

    def __init__(self, task_factory, context, policy):

\OpenStack\glance-2014.1\glance\api\property_protections.py

class ProtectedImageFactoryProxy(glance.domain.proxy.ImageFactory):

    def __init__(self, image_factory, context, property_rules):

    def new_image(self, **kwargs):

class ProtectedImageRepoProxy(glance.domain.proxy.Repo):

    def __init__(self, image_repo, context, property_rules):

    def get(self, image_id):

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

class ProtectedImageProxy(glance.domain.proxy.Image):

    def __init__(self, image, context, property_rules):

class ExtraPropertiesProxy(glance.domain.ExtraProperties):

    def __init__(self, context, extra_props, property_rules):

    def __getitem__(self, key):

    def __setitem__(self, key, value):

    def __delitem__(self, key):

\OpenStack\glance-2014.1\glance\api\v1\controller.py

class BaseController(object):

    def get_image_meta_or_404(self, request, image_id):

    def get_active_image_meta_or_404(self, request, image_id):

    def update_store_acls(self, req, image_id, location_uri, public=False):

\OpenStack\glance-2014.1\glance\api\v1\filters.py

def validate(filter, value):

def validate_int_in_range(min=0, max=None):

def validate_boolean(v):

\OpenStack\glance-2014.1\glance\api\v1\images.py

def validate_image_meta(req, values):

def redact_loc(image_meta, copy_dict=True):

class Controller(controller.BaseController):

    def __init__(self):

    def _enforce(self, req, action):

    def _enforce_image_property_quota(self, image_meta, orig_image_meta=None, purge_props=False, req=None):

    def _enforce_create_protected_props(self, create_props, req):

    def _enforce_read_protected_props(self, image_meta, req):

    def _enforce_update_protected_props(self, update_props, image_meta, orig_meta, req):

    def _enforce_delete_protected_props(self, delete_props, image_meta, orig_meta, req):

    def index(self, req):

    def detail(self, req):

    def _get_query_params(self, req):

    def _get_filters(self, req):

    def meta(self, req, id):

    def _validate_source(source, req):

    def _copy_from(req):

    def _external_source(self, image_meta, req):

    def _get_from_store(context, where):

    def show(self, req, id):

    def _reserve(self, req, image_meta):

    def _upload(self, req, image_meta):

    def _activate(self, req, image_id, location, location_metadata=None, from_state=None):

    def _upload_and_activate(self, req, image_meta):

    def _get_size(self, context, image_meta, location):

    def _handle_source(self, req, image_id, image_meta, image_data):

    def _validate_image_for_activation(self, req, id, values):

    def create(self, req, image_meta, image_data):

    def update(self, req, id, image_meta, image_data):

    def delete(self, req, id):

    def get_store_or_400(self, request, scheme):

class ImageDeserializer(wsgi.JSONRequestDeserializer):

    def _deserialize(self, request):

    def create(self, request):

    def update(self, request):

class ImageSerializer(wsgi.JSONResponseSerializer):

    def __init__(self):

    def _inject_location_header(self, response, image_meta):

    def _inject_checksum_header(self, response, image_meta):

    def _inject_image_meta_headers(self, response, image_meta):

    def _get_image_location(self, image_meta):

    def meta(self, response, result):

    def show(self, response, result):

    def update(self, response, result):

    def create(self, response, result):

def create_resource():

\OpenStack\glance-2014.1\glance\api\v1\members.py

class Controller(controller.BaseController):

    def __init__(self):

    def _check_can_access_image_members(self, context):

    def _enforce(self, req, action):

    def _raise_404_if_image_deleted(self, req, image_id):

    def index(self, req, image_id):

    def delete(self, req, image_id, id):

    def default(self, req, image_id, id, body=None):

    def _enforce_image_member_quota(self, req, attempted):

    def update(self, req, image_id, id, body=None):

    def update_all(self, req, image_id, body):

    def index_shared_images(self, req, id):

    def _update_store_acls(self, req, image_id):

def create_resource():

\OpenStack\glance-2014.1\glance\api\v1\router.py

class API(wsgi.Router):

    def __init__(self, mapper):

\OpenStack\glance-2014.1\glance\api\v1\upload_utils.py

def initiate_deletion(req, location, id, delayed_delete=False):

def _kill(req, image_id):

def safe_kill(req, image_id):

def upload_data_to_store(req, image_meta, image_data, store, notifier):

\OpenStack\glance-2014.1\glance\api\v1\__init__.py

\OpenStack\glance-2014.1\glance\api\v2\images.py

class ImagesController(object):

    def __init__(self, db_api=None, policy_enforcer=None, notifier=None, store_api=None):

    def create(self, req, image, extra_properties, tags):

    def index(self, req, marker=None, limit=None, sort_key='created_at', sort_dir='desc', filters=None, member_status='accepted'):

    def show(self, req, image_id):

    def update(self, req, image_id, changes):

    def _do_replace(self, req, image, change):

    def _do_add(self, req, image, change):

    def _do_remove(self, req, image, change):

    def delete(self, req, image_id):

    def _get_locations_op_pos(self, path_pos, max_pos, allow_max):

    def _do_replace_locations(self, image, value):

    def _do_add_locations(self, image, path_pos, value):

    def _do_remove_locations(self, image, path_pos):

class RequestDeserializer(wsgi.JSONRequestDeserializer):

    def __init__(self, schema=None):

    def _get_request_body(self, request):

    def _check_allowed(cls, image):

    def create(self, request):

    def _get_change_operation_d10(self, raw_change):

    def _get_change_operation_d4(self, raw_change):

    def _get_change_path_d10(self, raw_change):

    def _get_change_path_d4(self, raw_change, op):

    def _decode_json_pointer(self, pointer):

    def _validate_json_pointer(self, pointer):

    def _get_change_value(self, raw_change, op):

    def _validate_change(self, change):

    def _validate_path(self, op, path):

    def _parse_json_schema_change(self, raw_change, draft_version):

    def update(self, request):

    def _validate_limit(self, limit):

    def _validate_sort_dir(self, sort_dir):

    def _validate_member_status(self, member_status):

    def _get_filters(self, filters):

    def index(self, request):

class ResponseSerializer(wsgi.JSONResponseSerializer):

    def __init__(self, schema=None):

    def _get_image_href(self, image, subcollection=''):

    def _format_image(self, image):

    def create(self, response, image):

    def show(self, response, image):

    def update(self, response, image):

    def index(self, response, result):

    def delete(self, response, result):

def _get_base_properties():

def _get_base_links():

def get_schema(custom_properties=None):

def get_collection_schema(custom_properties=None):

def load_custom_properties():

def create_resource(custom_properties=None):

\OpenStack\glance-2014.1\glance\api\v2\image_data.py

class ImageDataController(object):

    def __init__(self, db_api=None, store_api=None, policy_enforcer=None, notifier=None, gateway=None):

    def _restore(self, image_repo, image):

    def upload(self, req, image_id, data, size):

    def download(self, req, image_id):

class RequestDeserializer(wsgi.JSONRequestDeserializer):

    def upload(self, request):

class ResponseSerializer(wsgi.JSONResponseSerializer):

    def download(self, response, image):

    def upload(self, response, result):

def create_resource():

\OpenStack\glance-2014.1\glance\api\v2\image_members.py

class ImageMembersController(object):

    def __init__(self, db_api=None, policy_enforcer=None, notifier=None, store_api=None):

    def create(self, req, image_id, member_id):

    def update(self, req, image_id, member_id, status):

    def index(self, req, image_id):

    def show(self, req, image_id, member_id):

    def delete(self, req, image_id, member_id):

class RequestDeserializer(wsgi.JSONRequestDeserializer):

    def __init__(self):

    def _get_request_body(self, request):

    def create(self, request):

    def update(self, request):

class ResponseSerializer(wsgi.JSONResponseSerializer):

    def __init__(self, schema=None):

    def _format_image_member(self, member):

    def create(self, response, image_member):

    def update(self, response, image_member):

    def index(self, response, image_members):

    def show(self, response, image_member):

def get_schema():

def get_collection_schema():

def create_resource():

\OpenStack\glance-2014.1\glance\api\v2\image_tags.py

class Controller(object):

    def __init__(self, db_api=None, policy_enforcer=None, notifier=None, store_api=None):

    def update(self, req, image_id, tag_value):

    def delete(self, req, image_id, tag_value):

class ResponseSerializer(wsgi.JSONResponseSerializer):

    def update(self, response, result):

    def delete(self, response, result):

def create_resource():

\OpenStack\glance-2014.1\glance\api\v2\router.py

class API(wsgi.Router):

    def __init__(self, mapper):

\OpenStack\glance-2014.1\glance\api\v2\schemas.py

class Controller(object):

    def __init__(self, custom_image_properties=None):

    def image(self, req):

    def images(self, req):

    def member(self, req):

    def members(self, req):

    def task(self, req):

    def tasks(self, req):

def create_resource(custom_image_properties=None):

\OpenStack\glance-2014.1\glance\api\v2\tasks.py

class TasksController(object):

    def __init__(self, db_api=None, policy_enforcer=None, notifier=None, store_api=None):

    def create(self, req, task):

    def index(self, req, marker=None, limit=None, sort_key='created_at', sort_dir='desc', filters=None):

    def get(self, req, task_id):

    def delete(self, req, task_id):

class RequestDeserializer(wsgi.JSONRequestDeserializer):

    def _get_request_body(self, request):

    def _validate_sort_dir(self, sort_dir):

    def _get_filters(self, filters):

    def _validate_marker(self, marker):

    def _validate_limit(self, limit):

    def _validate_create_body(self, body):

    def __init__(self, schema=None):

    def create(self, request):

    def index(self, request):

class ResponseSerializer(wsgi.JSONResponseSerializer):

    def __init__(self, task_schema=None, partial_task_schema=None):

    def _inject_location_header(self, response, task):

    def _get_task_location(self, task):

    def _format_task(self, schema, task, task_details=None):

    def create(self, response, result):

    def get(self, response, result):

    def _get(self, response, task, task_details):

    def index(self, response, result):

def get_task_schema():

def _get_partial_task_schema():

def get_collection_schema():

def create_resource():

\OpenStack\glance-2014.1\glance\api\v2\__init__.py

\OpenStack\glance-2014.1\glance\api\versions.py

class Controller(object):

    def index(self, req):

        def build_version_object(version, path, status):

    def __call__(self, req):

def create_resource(conf):

\OpenStack\glance-2014.1\glance\api\__init__.py

def root_app_factory(loader, global_conf, **local_conf):

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

def fail(returncode, e):

def main():

\OpenStack\glance-2014.1\glance\cmd\cache_cleaner.py

def main():

\OpenStack\glance-2014.1\glance\cmd\cache_manage.py

def catch_error(action):

def list_cached(options, args):

def list_queued(options, args):

def queue_image(options, args):

def delete_cached_image(options, args):

def delete_all_cached_images(options, args):

def delete_queued_image(options, args):

def delete_all_queued_images(options, args):

def get_client(options):

def env(*vars, **kwargs):

def create_options(parser):

def parse_options(parser, cli_args):

def print_help(options, args):

def lookup_command(parser, command_name):

def user_confirm(prompt, default=False):

def main():

\OpenStack\glance-2014.1\glance\cmd\cache_prefetcher.py

def main():

\OpenStack\glance-2014.1\glance\cmd\cache_pruner.py

def main():

\OpenStack\glance-2014.1\glance\cmd\control.py

def gated_by(predicate):

def pid_files(server, pid_file):

def do_start(verb, pid_file, server, args):

def do_check_status(pid_file, server):

def get_pid_file(server, pid_file):

def do_stop(server, args, graceful=False):

def add_command_parsers(subparsers):

def main():

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

def args(*args, **kwargs):

 def _decorator(func):

class DbCommands(object):

    def __init__(self):

    def _need_sanity_check(self):

    def version(self):

    def upgrade(self, version=None):

    def downgrade(self, version=None):

    def version_control(self, version=None):

    def sync(self, version=None, current_version=None):

class DbLegacyCommands(object):

    def __init__(self, command_object):

    def version(self):

    def upgrade(self, version=None):

    def downgrade(self, version=None):

    def version_control(self, version=None):

    def sync(self, version=None, current_version=None):

def add_legacy_command_parsers(command_object, subparsers):

def add_command_parsers(subparsers):

def methods_of(obj):

def main():

\OpenStack\glance-2014.1\glance\cmd\registry.py

def main():

\OpenStack\glance-2014.1\glance\cmd\replicator.py

class AuthenticationException(Exception):

class ImageAlreadyPresentException(Exception):

class ServerErrorException(Exception):

class UploadException(Exception):

class ImageService(object):

    def __init__(self, conn, auth_token):

    def _http_request(self, method, url, headers, body, ignore_result_body=False):

    def get_images(self):

    def get_image(self, image_uuid):

    def _header_list_to_dict(headers):

    def get_image_meta(self, image_uuid):

    def _dict_to_headers(d):

    def add_image(self, image_meta, image_data):

    def add_image_meta(self, image_meta):

def get_image_service():

def replication_size(options, args):

def replication_dump(options, args):

def _dict_diff(a, b):

def is_uuid_like(value):

def replication_load(options, args):

def replication_livecopy(options, args):

def replication_compare(options, args):

def _check_upload_response_headers(headers, body):

def _image_present(client, image_uuid):

def parse_options(parser, cli_args):

def print_help(options, args):

def lookup_command(parser, command_name):

def logging_excepthook(type, value, tb):

def main():

\OpenStack\glance-2014.1\glance\cmd\scrubber.py

def main():

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

\OpenStack\glance-2014.1\glance\common\auth.py

class BaseStrategy(object):

    def __init__(self):

    def authenticate(self):

    def is_authenticated(self):

    def strategy(self):

class NoAuthStrategy(BaseStrategy):

    def authenticate(self):

    def is_authenticated(self):

    def strategy(self):

class KeystoneStrategy(BaseStrategy):

    def __init__(self, creds, insecure=False, configure_via_auth=True):

    def check_auth_params(self):

    def authenticate(self):

        def _authenticate(auth_url):

    def _v1_auth(self, token_url):

        def _management_url(self, resp):

    def _v2_auth(self, token_url):

    def is_authenticated(self):

    def strategy(self):

    def _do_request(self, url, method, headers=None, body=None):

def get_plugin_from_strategy(strategy, creds=None, insecure=False, configure_via_auth=True):

def get_endpoint(service_catalog, service_type='image', endpoint_region=None, endpoint_type='publicURL'):

\OpenStack\glance-2014.1\glance\common\client.py

def handle_unauthenticated(func):

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

def handle_redirects(func):

 def wrapped(self, method, url, body, headers):

class HTTPSClientAuthConnection(httplib.HTTPSConnection):

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

    def connect(self):

class BaseClient(object):

    def __init__(self, host, port=None, timeout=None, use_ssl=False, auth_tok=None, creds=None, doc_root=None, key_file=None, cert_file=None, ca_file=None, insecure=False, configure_via_auth=True):

    def get_connect_kwargs(self):

    def set_auth_token(self, auth_tok):

    def configure_from_url(self, url):

    def make_auth_plugin(self, creds, insecure):

    def get_connection_type(self):

    def _authenticate(self, force_reauth=False):

    def do_request(self, method, action, body=None, headers=None, params=None):

    def _construct_url(self, action, params=None):

    def _encode_headers(self, headers):

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

    def _seekable(self, body):

    def _sendable(self, body):

    def _iterable(self, body):

    def image_iterator(self, connection, headers, body):

    def get_status_code(self, response):

    def _extract_params(self, actual_params, allowed_params):

\OpenStack\glance-2014.1\glance\common\config.py

def parse_args(args=None, usage=None, default_config_files=None):

def parse_cache_args(args=None):

def _get_deployment_flavor(flavor=None):

def _get_paste_config_path():

def _get_deployment_config_file():

def load_paste_app(app_name, flavor=None, conf_file=None):

\OpenStack\glance-2014.1\glance\common\crypt.py

def urlsafe_encrypt(key, plaintext, blocksize=16):

def urlsafe_decrypt(key, ciphertext):

\OpenStack\glance-2014.1\glance\common\exception.py

class RedirectException(Exception):

    def __init__(self, url):

class GlanceException(Exception):

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

    def __unicode__(self):

class MissingCredentialError(GlanceException):

class BadAuthStrategy(GlanceException):

class NotFound(GlanceException):

class UnknownScheme(GlanceException):

class BadStoreUri(GlanceException):

class Duplicate(GlanceException):

class Conflict(GlanceException):

class StorageFull(GlanceException):

class StorageQuotaFull(GlanceException):

class StorageWriteDenied(GlanceException):

class AuthBadRequest(GlanceException):

class AuthUrlNotFound(GlanceException):

class AuthorizationFailure(GlanceException):

class NotAuthenticated(GlanceException):

class Forbidden(GlanceException):

class ForbiddenPublicImage(Forbidden):

class ProtectedImageDelete(Forbidden):

class Invalid(GlanceException):

class InvalidSortKey(Invalid):

class InvalidPropertyProtectionConfiguration(Invalid):

class InvalidFilterRangeValue(Invalid):

class ReadonlyProperty(Forbidden):

class ReservedProperty(Forbidden):

class AuthorizationRedirect(GlanceException):

class ClientConnectionError(GlanceException):

class ClientConfigurationError(GlanceException):

class MultipleChoices(GlanceException):

class LimitExceeded(GlanceException):

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

class ServiceUnavailable(GlanceException):

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

class ServerError(GlanceException):

class UnexpectedStatus(GlanceException):

class InvalidContentType(GlanceException):

class BadRegistryConnectionConfiguration(GlanceException):

class BadStoreConfiguration(GlanceException):

class BadDriverConfiguration(GlanceException):

class StoreDeleteNotSupported(GlanceException):

class StoreGetNotSupported(GlanceException):

class StoreAddNotSupported(GlanceException):

class StoreAddDisabled(GlanceException):

class MaxRedirectsExceeded(GlanceException):

class InvalidRedirect(GlanceException):

class NoServiceEndpoint(GlanceException):

class RegionAmbiguity(GlanceException):

class WorkerCreationFailure(GlanceException):

class SchemaLoadError(GlanceException):

class InvalidObject(GlanceException):

class UnsupportedHeaderFeature(GlanceException):

class InUseByStore(GlanceException):

class ImageSizeLimitExceeded(GlanceException):

class ImageMemberLimitExceeded(LimitExceeded):

class ImagePropertyLimitExceeded(LimitExceeded):

class ImageTagLimitExceeded(LimitExceeded):

class ImageLocationLimitExceeded(LimitExceeded):

class RPCError(GlanceException):

class TaskException(GlanceException):

class TaskNotFound(TaskException, NotFound):

class InvalidTaskStatus(TaskException, Invalid):

class InvalidTaskType(TaskException, Invalid):

class InvalidTaskStatusTransition(TaskException, Invalid):

class DuplicateLocation(Duplicate):

class ImageDataNotFound(NotFound):

class InvalidParameterValue(Invalid):

class InvalidImageStatusTransition(Invalid):

\OpenStack\glance-2014.1\glance\common\location_strategy\location_order.py

def get_strategy_name():

def init():

def get_ordered_locations(locations, **kwargs):

\OpenStack\glance-2014.1\glance\common\location_strategy\store_type.py

def get_strategy_name():

def init():

def get_ordered_locations(locations, uri_key='url', **kwargs):

\OpenStack\glance-2014.1\glance\common\location_strategy\__init__.py

def _load_strategies():

def verify_location_strategy(conf=None, strategies=_available_strategies):

def get_ordered_locations(locations, **kwargs):

def choose_best_location(locations, **kwargs):

\OpenStack\glance-2014.1\glance\common\property_utils.py

def is_property_protection_enabled():

class PropertyRules(object):

    def __init__(self, policy_enforcer=None):

    def _load_rules(self):

    def _compile_rule(self, rule):

    def _add_policy_rules(self, property_exp, action, rule):

    def _check_policy(self, property_exp, action, context):

    def check_property_rules(self, property_name, action, context):

\OpenStack\glance-2014.1\glance\common\rpc.py

class RPCJSONSerializer(wsgi.JSONResponseSerializer):

    def _sanitizer(self, obj):

        def to_primitive(_type, _value):

class RPCJSONDeserializer(wsgi.JSONRequestDeserializer):

    def _to_datetime(self, obj):

    def _sanitizer(self, obj):

class Controller(object):

    def __init__(self, raise_exc=False):

    def register(self, resource, filtered=None, excluded=None, refiner=None):

    def __call__(self, req, body):

        def validate(cmd):

class RPCClient(client.BaseClient):

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

    def bulk_request(self, commands):

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

    def __getattr__(self, item):

        def method_proxy(**kw):

\OpenStack\glance-2014.1\glance\common\utils.py

def chunkreadable(iter, chunk_size=65536):

def chunkiter(fp, chunk_size=65536):

def cooperative_iter(iter):

def cooperative_read(fd):

 def readfn(*args):

class CooperativeReader(object):

    def __init__(self, fd):

    def read(self, length=None):

    def __iter__(self):

class LimitingReader(object):

    def __init__(self, data, limit):

    def __iter__(self):

    def read(self, i):

def image_meta_to_http_headers(image_meta):

def add_features_to_http_headers(features, headers):

def get_image_meta_from_headers(response):

def safe_mkdirs(path):

def safe_remove(path):

class PrettyTable(object):

    def __init__(self):

    def add_column(self, width, label="", just='l'):

    def make_header(self):

    def make_row(self, *args):

    def _clip_and_justify(data, width, just):

def get_terminal_size():

    def _get_terminal_size_posix():

    def _get_terminal_size_win32():

    def _get_terminal_size_unknownOS():

def mutating(func):

    def wrapped(self, req, *args, **kwargs):

def setup_remote_pydev_debug(host, port):

class LazyPluggable(object):

    def __init__(self, pivot, config_group=None, **backends):

    def __get_backend(self):

    def __getattr__(self, key):

def validate_key_cert(key_file, cert_file):

def get_test_suite_socket():

def is_uuid_like(val):

\OpenStack\glance-2014.1\glance\common\wsgi.py

def get_bind_addr(default_port=None):

def get_socket(default_port):

 def wrap_ssl(sock):

class Server(object):

    def __init__(self, threads=1000):

    def start(self, application, default_port):

        def kill_children(*args):

        def hup(*args):

    def create_pool(self):

    def wait_on_children(self):

    def wait(self):

    def run_child(self):

    def run_server(self):

    def _single_run(self, application, sock):

class Middleware(object):

    def __init__(self, application):

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

        def filter(app):

    def process_request(self, req):

    def process_response(self, response):

    def __call__(self, req):

class Debug(Middleware):

    def __call__(self, req):

    def print_generator(app_iter):

class APIMapper(routes.Mapper):

    def routematch(self, url=None, environ=None):

class Router(object):

    def __init__(self, mapper):

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

    def __call__(self, req):

    def _dispatch(req):

class Request(webob.Request):

    def best_match_content_type(self):

    def get_content_type(self, allowed_content_types):

    def best_match_language(self):

class JSONRequestDeserializer(object):

    def has_body(self, request):

    def _sanitizer(self, obj):

    def from_json(self, datastring):

    def default(self, request):

class JSONResponseSerializer(object):

    def _sanitizer(self, obj):

    def to_json(self, data):

    def default(self, response, result):

def translate_exception(req, e):

class Resource(object):

    def __init__(self, controller, deserializer=None, serializer=None):

    def __call__(self, request):

    def dispatch(self, obj, action, *args, **kwargs):

    def get_action_args(self, request_environment):

\OpenStack\glance-2014.1\glance\common\__init__.py

\OpenStack\glance-2014.1\glance\context.py

class RequestContext(object):

    def __init__(self, auth_tok=None, user=None, tenant=None, roles=None, is_admin=False, read_only=False, show_deleted=False, owner_is_tenant=True, service_catalog=None, policy_enforcer=None, domain=None, user_domain=None, project_domain=None):

    def to_dict(self):

    def from_dict(cls, values):

    def update_store(self):

    def owner(self):

    def show_deleted(self):

\OpenStack\glance-2014.1\glance\db\migration.py

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

\OpenStack\glance-2014.1\glance\db\registry\api.py

def configure():

def _get_client(func):

def image_create(client, values):

def image_update(client, image_id, values, purge_props=False, from_state=None):

def image_destroy(client, image_id):

def image_get(client, image_id, force_show_deleted=False):

def is_image_visible(context, image, status=None):

def image_get_all(client, filters=None, marker=None, limit=None, sort_key='created_at', sort_dir='desc', member_status='accepted', is_public=None, admin_as_user=False):

def image_property_create(client, values, session=None):

def image_property_delete(client, prop_ref, image_ref, session=None):

def image_member_create(client, values, session=None):

def image_member_update(client, memb_id, values):

def image_member_delete(client, memb_id, session=None):

def image_member_find(client, image_id=None, member=None, status=None):

def image_member_count(client, image_id):

def image_tag_set_all(client, image_id, tags):

def image_tag_create(client, image_id, value, session=None):

def image_tag_delete(client, image_id, value, session=None):

def image_tag_get_all(client, image_id, session=None):

def user_get_storage_usage(client, owner_id, image_id=None, session=None):

\OpenStack\glance-2014.1\glance\db\registry\__init__.py

\OpenStack\glance-2014.1\glance\db\simple\api.py

def log_call(func):

def reset():

def clear_db_env(*args, **kwargs):

def _get_session():

def _image_locations_format(image_id, value, meta_data):

def _image_property_format(image_id, name, value):

def _image_member_format(image_id, tenant_id, can_share, status='pending'):

def _pop_task_info_values(values):

def _format_task_from_db(task_ref, task_info_ref):

def _task_format(task_id, **values):

def _task_info_format(task_id, **values):

def _image_format(image_id, **values):

def _filter_images(images, filters, context, status='accepted', is_public=None, admin_as_user=False):

def _do_pagination(context, images, marker, limit, show_deleted, status='accepted'):

def _sort_images(images, sort_key, sort_dir):

def _image_get(context, image_id, force_show_deleted=False, status=None):

def image_get(context, image_id, session=None, force_show_deleted=False):

def image_get_all(context, filters=None, marker=None, limit=None, sort_key='created_at', sort_dir='desc', member_status='accepted', is_public=None, admin_as_user=False):

def image_property_create(context, values):

def image_property_delete(context, prop_ref, image_ref, session=None):

def image_member_find(context, image_id=None, member=None, status=None):

def image_member_count(context, image_id):

def image_member_create(context, values):

def image_member_update(context, member_id, values):

def image_member_delete(context, member_id):

def _image_locations_set(image_id, locations):

def _normalize_locations(image):

def _image_location_get_all(image_id):

def image_create(context, image_values):

def image_update(context, image_id, image_values, purge_props=False, from_state=None):

def image_destroy(context, image_id):

def image_tag_get_all(context, image_id):

def image_tag_get(context, image_id, value):

def image_tag_set_all(context, image_id, values):

def image_tag_create(context, image_id, value):

def image_tag_delete(context, image_id, value):

def is_image_mutable(context, image):

def is_image_visible(context, image, status=None):

def user_get_storage_usage(context, owner_id, image_id=None, session=None):

def task_create(context, values):

def task_update(context, task_id, values):

def task_get(context, task_id, force_show_deleted=False):

def _task_get(context, task_id, force_show_deleted=False):

def task_delete(context, task_id):

def task_get_all(context, filters=None, marker=None, limit=None, sort_key='created_at', sort_dir='desc'):

def _is_task_visible(context, task):

def _filter_tasks(tasks, filters, context, admin_as_user=False):

def _sort_tasks(tasks, sort_key, sort_dir):

def _paginate_tasks(context, tasks, marker, limit, show_deleted):

def _task_info_create(task_id, values):

def _task_info_update(task_id, values):

def _task_info_get(task_id):

\OpenStack\glance-2014.1\glance\db\simple\__init__.py

\OpenStack\glance-2014.1\glance\db\sqlalchemy\api.py

def _create_facade_lazily():

def get_engine():

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

def clear_db_env():

def _check_mutate_authorization(context, image_ref):

def image_create(context, values):

def image_update(context, image_id, values, purge_props=False, from_state=None):

def image_destroy(context, image_id):

def _normalize_locations(image):

def image_get(context, image_id, session=None, force_show_deleted=False):

def _check_image_id(image_id):

def _image_get(context, image_id, session=None, force_show_deleted=False):

def is_image_mutable(context, image):

def is_image_visible(context, image, status=None):

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

def _make_conditions_from_filters(filters, is_public=None):

def _make_image_property_condition(key, value):

def _select_images_query(context, image_conditions, admin_as_user, member_status, visibility):

def image_get_all(context, filters=None, marker=None, limit=None, sort_key='created_at', sort_dir='desc', member_status='accepted', is_public=None, admin_as_user=False):

def _drop_protected_attrs(model_class, values):

def _image_get_disk_usage_by_owner(owner, session, image_id=None):

def _validate_image(values):

def _update_values(image_ref, values):

def _image_update(context, values, image_id, purge_props=False, from_state=None):

def _image_locations_set(image_id, locations, session):

def _image_locations_delete_all(context, image_id, delete_time=None, session=None):

def _set_properties_for_image(context, image_ref, properties, purge_props=False, session=None):

def _image_child_entry_delete_all(child_model_cls, image_id, delete_time=None, session=None):

def image_property_create(context, values, session=None):

def _image_property_update(context, prop_ref, values, session=None):

def image_property_delete(context, prop_ref, image_ref, session=None):

def _image_property_delete_all(context, image_id, delete_time=None, session=None):

def image_member_create(context, values, session=None):

def _image_member_format(member_ref):

def image_member_update(context, memb_id, values):

def _image_member_update(context, memb_ref, values, session=None):

def image_member_delete(context, memb_id, session=None):

def _image_member_delete(context, memb_ref, session):

def _image_member_delete_all(context, image_id, delete_time=None, session=None):

def _image_member_get(context, memb_id, session):

def image_member_find(context, image_id=None, member=None, status=None):

def _image_member_find(context, session, image_id=None, member=None, status=None):

OpenStack Index

Next