Synnefo

   PITHOS_SERVICE_TOKEN = 'pithos_service_token22w'

The ``PITHOS_BACKEND_DB_CONNECTION`` option tells to the Pithos app where to

find the Pithos backend database. Above we tell Pithos that its database is

    PITHOS_UPDATE_MD5 = False

    PITHOS_SERVICE_TOKEN = 'XXXXXXXXXXX'

Install pithos web UI with:

ASTAKOS_IM_MODULES = ['local', 'shibboleth']

ASTAKOS_BASE_URL = 'http://accounts.example.synnefo.org/astakos/'

ASTAKOS_AUTH_URL = 'http://accounts.example.synnefo.org/astakos/identity/v2.0/'

#PITHOS_BASE_URL = "https://pithos.example.synnefo.org/"

# Top-level URL for the Astakos instance to be used for user management

# Cookie name to search for fallback token

#PITHOS_ASTAKOS_COOKIE_NAME = '_pithos2_a'

# identity management.  WARNING: Setting to True will break your installation.

# PITHOS_TRANSLATE_UUIDS = False

# Tune the size of the http pool for the astakos client.

# It limits the maximum number of quota changing requests

)

from pithos.api.settings import (UPDATE_MD5, TRANSLATE_UUIDS,

from pithos.api import settings

def get_uuids(names):

    try:

    except Exception, e:

        logger.exception(e)

        return {}

                if name != x[:name_idx]:

                    continue

                objects_bulk.append(x[name_idx:])

            if len(objects_bulk) > 0:

                object_permissions = \

                    request.backend.get_object_permissions_bulk(

        b = get_backend()

        try:

            b.pre_exec()

            if pending_commissions:

                self.stdout.write(

                to_accept = b.commission_serials.lookup(pending_commissions)

                to_reject = list(set(pending_commissions) - set(to_accept))

                response = b.astakosclient.resolve_commissions(

                    accept_serials=to_accept,

                    reject_serials=to_reject

                )

#coding=utf8

from django.conf import settings

from synnefo.lib import parse_base_url, join_urls

from pithos.api.services import pithos_services as vanilla_pithos_services

from copy import deepcopy

# Top-level URL for Pithos. Must set.

BASE_URL = getattr(settings, 'PITHOS_BASE_URL',

                   "https://object-store.example.synnefo.org/pithos/")

BASE_HOST, BASE_PATH = parse_base_url(BASE_URL)

pithos_services = deepcopy(vanilla_pithos_services)

fill_endpoints(pithos_services, BASE_URL)

PITHOS_PREFIX = get_path(pithos_services, 'pithos_object-store.prefix')

PUBLIC_PREFIX = get_path(pithos_services, 'pithos_public.prefix')

UI_PREFIX = get_path(pithos_services, 'pithos_ui.prefix')

# SQLAlchemy (choose SQLite/MySQL/PostgreSQL).

BACKEND_DB_MODULE = getattr(

# Update object checksums.

UPDATE_MD5 = getattr(settings, 'PITHOS_UPDATE_MD5', False)

RADOS_STORAGE = getattr(settings, 'PITHOS_RADOS_STORAGE', False)

RADOS_POOL_BLOCKS = getattr(settings, 'PITHOS_RADOS_POOL_BLOCKS', 'blocks')

RADOS_POOL_MAPS = getattr(settings, 'PITHOS_RADOS_POOL_MAPS', 'maps')

# identity management.  WARNING: Setting to True will break your installation.

TRANSLATE_UUIDS = getattr(settings, 'PITHOS_TRANSLATE_UUIDS', False)

# Set how many random bytes to use for constructing the URL

# of Pithos public files

PUBLIC_URL_SECURITY = getattr(settings, 'PITHOS_PUBLIC_URL_SECURITY', 16)

# The backend block hash algorithm

BACKEND_HASH_ALGORITHM = getattr(

    settings, 'PITHOS_BACKEND_HASH_ALGORITHM', 'sha256')

from snf_django.lib.api import api_endpoint_not_found

from snf_django.utils.urls import extend_endpoint_with_slash

from pithos.api.settings import (

urlpatterns = []

    (prefix_pattern(BASE_PATH), include(pithos_patterns)),

)

                                 BACKEND_QUEUE_EXCHANGE,

                                 ASTAKOSCLIENT_POOLSIZE,

                                 SERVICE_TOKEN,

                                 BACKEND_ACCOUNT_QUOTA,

                                 BACKEND_CONTAINER_QUOTA,

                                 BACKEND_VERSIONING, BACKEND_FREE_VERSIONING,

    for timestamp in timestamps:

        if timestamp in d and d[timestamp]:

            d[timestamp] = utils.isoformat(

    return dict([(k.lower().replace('-', '_'), v) for k, v in d.iteritems()])

##########################

def retrieve_displayname(token, uuid, fail_silently=True):

                            logger=logger)

    try:

    except NoUserName:

        if not fail_silently:

            raise ItemNotExists(uuid)

def retrieve_displaynames(token, uuids, return_dict=False, fail_silently=True):

                            logger=logger)

    missing = list(set(uuids) - set(catalog))

    if missing and not fail_silently:

        raise ItemNotExists('Unknown displaynames: %s' % ', '.join(missing))

    if is_uuid(displayname):

        return displayname

                            logger=logger)

    try:

    except NoUUID:

        raise ItemNotExists(displayname)

    return uuid

def retrieve_uuids(token, displaynames, return_dict=False, fail_silently=True):

                            logger=logger)

    missing = list(set(displaynames) - set(catalog))

    if missing and not fail_silently:

        raise ItemNotExists('Unknown uuids: %s' % ', '.join(missing))

    queue_module=BACKEND_QUEUE_MODULE,

    queue_hosts=BACKEND_QUEUE_HOSTS,

    queue_exchange=BACKEND_QUEUE_EXCHANGE,

    service_token=SERVICE_TOKEN,

    astakosclient_poolsize=ASTAKOSCLIENT_POOLSIZE,

    free_versioning=BACKEND_FREE_VERSIONING,

def get_pithos_usage(token):

    """Get Pithos Usage from astakos."""

                            logger=logger)

    pithos_resources = [r['name'] for r in resources]

    map(quotas.pop, filter(lambda k: k not in pithos_resources, quotas.keys()))

    return quotas.popitem()[-1]  # assume only one resource

        @api.api_method(http_method=http_method, token_required=token_required,

                        user_required=user_required,

                        logger=logger, format_allowed=format_allowed,

                        serializations=serializations,

                        strict_serlization=strict_serlization)

        @wraps(func)

catalog = {}

    global catalog

    if account in catalog:

        return catalog[account]

    try:

        print '\n', account, '-->', catalog[account]

    except NoUUID:

        return None

inverse_catalog = {}

    global inverse_catalog

    if account in inverse_catalog:

        return inverse_catalog[account]

    try:

        print '\n', account, '-->', inverse_catalog[account]

    except NoUserName:

        return None

    except ImportError:

        return

    else:

        get_uuid = functools.partial(_get_uuid,

                                     service_token=settings.SERVICE_TOKEN,

                                     astakos_client=astakos_client)

    except ImportError:

        return

    else:

        get_displayname = functools.partial(

            _get_displayname,

            astakos_client=astakos_client)

        migrate(get_displayname)

                 block_module=None, block_path=None, block_umask=None,

                 block_size=None, hash_algorithm=None,

                 queue_module=None, queue_hosts=None, queue_exchange=None,

                 astakosclient_poolsize=None,

                 free_versioning=True, block_params=None,

                 public_url_security=None,

            self.queue = NoQueue()

        self.service_token = service_token

            self.astakosclient = DisabledAstakosClient(

                use_pool=True,

                pool_size=astakosclient_poolsize)

        else:

            self.astakosclient = AstakosClient(

                use_pool=True,

                pool_size=astakosclient_poolsize)

                self.wrapper.execute()

                r = self.astakosclient.resolve_commissions(

                    accept_serials=self.serials,

                    reject_serials=[])

                self.commission_serials.delete_many(

        else:

            if self.serials:

                self.astakosclient.resolve_commissions(

                    accept_serials=[],

                    reject_serials=self.serials)

                self.commission_serials.delete_many(

        try:

            name = details['path'] if 'path' in details else ''

            serial = self.astakosclient.issue_one_commission(

                holder=account,

                source=DEFAULT_SOURCE,

                provisions={'pithos.diskspace': size},

                 block_size=None, hash_algorithm=None,

                 queue_module=None, queue_hosts=None,

                 queue_exchange=None, free_versioning=True,

                 astakosclient_poolsize=None,

                 block_params=None,

                 public_url_security=None,

        self.block_params = block_params

        self.queue_hosts = queue_hosts

        self.queue_exchange = queue_exchange

        self.service_token = service_token

        self.astakosclient_poolsize = astakosclient_poolsize

        self.free_versioning = free_versioning

            block_params=self.block_params,

            queue_hosts=self.queue_hosts,

            queue_exchange=self.queue_exchange,

            service_token=self.service_token,

            astakosclient_poolsize=self.astakosclient_poolsize,

            free_versioning=self.free_versioning,