Synnefo

   CYCLADES_BASE_URL = 'https://node1.example.com/cyclades'

   ASTAKOS_BASE_URL = 'https://node1.example.com/astakos'

   CYCLADES_SERVICE_TOKEN = 'cyclades_service_token22w'

The ``ASTAKOS_BASE_URL`` denotes the Astakos endpoint for Cyclades,

ASTAKOS_IM_MODULES = ['local', 'shibboleth']

PITHOS_PROXY_USER_SERVICES = False

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

COMPUTE_BASE_URL = 'http://compute.example.synnefo.org/cyclades/'

PITHOS_BASE_URL = 'http://storage.example.synnefo.org/pithos/'

#MAX_PERSONALITY_SIZE = 10240

#

#

#

## Key for password encryption-decryption. After changing this setting, synnefo

## will be unable to decrypt all existing Backend passwords. You will need to

## using a user uuid)

#CYCLADES_SERVICE_TOKEN = ''

# Tune the size of the http connection pool to astakos.

#CYCLADES_ASTAKOSCLIENT_POOLSIZE = 50

from snf_django.management.commands import ListCommand

from synnefo.db.models import Network

from synnefo.settings import (CYCLADES_SERVICE_TOKEN as ASTAKOS_TOKEN,

from logging import getLogger

log = getLogger(__name__)

    object_class = Network

    deleted_field = "deleted"

    user_uuid_field = "userid"

    astakos_token = ASTAKOS_TOKEN

    def get_machines(network):

from synnefo.management.common import Omit

from synnefo.management import common

from synnefo.settings import (CYCLADES_SERVICE_TOKEN as ASTAKOS_TOKEN,

# Fields to print from a gnt-instance info

        displayname = options['displayname']

        try:

            image = common.get_image(vm.imageid, vm.userid)['name']

from synnefo.management.common import get_backend

from synnefo.api.util import get_image

from synnefo.settings import (CYCLADES_SERVICE_TOKEN as ASTAKOS_TOKEN,

from logging import getLogger

log = getLogger(__name__)

    object_class = VirtualMachine

    deleted_field = "deleted"

    user_uuid_field = "userid"

    astakos_token = ASTAKOS_TOKEN

    def get_public_ip(vm):

                                       get_image)

from snf_django.lib.astakos import UserCache

from synnefo.settings import (CYCLADES_SERVICE_TOKEN as ASTAKOS_TOKEN,

from snf_django.management import utils

            image_name = "None"

        image = '%s (%s)' % (imageid, image_name)

        kv = {

            'id': server.id,

            'name': server.name,

MAX_PERSONALITY_SIZE = 10240

# Tune the size of the Astakos http client connection pool

# This limit the number of concurrent requests to Astakos.

# using a user uuid)

CYCLADES_SERVICE_TOKEN = ''

# Template to use to build the FQDN of VMs. The setting will be formated with

# the id of the VM. If set to 'None' the first public IPv4 or IPv6 address

# of the VM will be used.

from snf_django.lib.api.urls import api_patterns

from synnefo.cyclades_settings import (

    BASE_PATH, COMPUTE_PREFIX, VMAPI_PREFIX,

    cyclades_services)

from functools import partial

extend_endpoint_with_slash(urlpatterns, cyclades_services, 'admin')

extend_endpoint_with_slash(urlpatterns, cyclades_services, 'cyclades_userdata')

cyclades_patterns = api_patterns(

    '',

    (prefix_pattern(VMAPI_PREFIX), include('synnefo.vmapi.urls')),

    (prefix_pattern(BASE_PATH), include(cyclades_patterns)),

)

# set utility redirects

extend_with_root_redirects(urlpatterns, cyclades_services, 'cyclades_ui',

                           BASE_PATH)

from synnefo.util.keypath import get_path, set_path

from synnefo.api.services import cyclades_services as vanilla_cyclades_services

from synnefo.lib.services import fill_endpoints

from copy import deepcopy

# Process Cyclades settings

BASE_URL = getattr(settings, 'CYCLADES_BASE_URL',

                   'https://compute.example.synnefo.org/compute/')

BASE_HOST, BASE_PATH = parse_base_url(BASE_URL)

CUSTOMIZE_SERVICES = getattr(settings, 'CYCLADES_CUSTOMIZE_SERVICES', ())

cyclades_services = deepcopy(vanilla_cyclades_services)

COMPUTE_ROOT_URL = join_urls(BASE_URL, COMPUTE_PREFIX)

# Process Astakos settings

    def __init__(*args, **kwargs):

        pass

        try:

            return USERS_UUIDS.get(uuid)['displayname']

        except TypeError:

            return None

        try:

            return USERS_DISPLAYNAMES.get(display_name)['uuid']

        except TypeError:

            raise Http404

        token = get_token_from_cookie(request, AUTH_COOKIE_NAME)

                         fallback_token=token, logger=logger)

        if hasattr(request, 'user') and request.user:

            groups = request.user.get('groups', [])

            account = None

            search_query = vmid

    account = None

    if is_uuid:

        account = search_query

        try:

        except:

            logger.info("Failed to resolve '%s' into account" % account)

    if account_exists and not is_uuid:

        account_name = search_query

        try:

        except:

            logger.info("Failed to resolve '%s' into account" % account_name)

from synnefo.db.models import FloatingIP

from snf_django.management.commands import ListCommand

from logging import getLogger

log = getLogger(__name__)

    object_class = FloatingIP

    deleted_field = "deleted"

    user_uuid_field = "userid"

    astakos_token = CYCLADES_SERVICE_TOKEN

    FIELDS = {

from synnefo.logic.rapi import GanetiApiError

from snf_django.lib.astakos import UserCache

from synnefo.settings import (CYCLADES_SERVICE_TOKEN as ASTAKOS_TOKEN,

from util import pool_map_chunks

        net = get_network(args[0])

        displayname = options['displayname']

        mrapi().StartupInstance.return_value = 1

        with mocked_quotaholder() as m:

            servers.start(vm)

                                                          [serial.serial])

            self.assertTrue(m.issue_one_commission.called)

        # Not pending, rejct

        mrapi().StartupInstance.return_value = 1

        with mocked_quotaholder() as m:

            servers.start(vm)

                                                          [serial.serial])

            self.assertTrue(m.issue_one_commission.called)

        # Not pending, accept

        mrapi().StartupInstance.return_value = 1

        with mocked_quotaholder() as m:

            servers.start(vm)

                                                          [])

            self.assertTrue(m.issue_one_commission.called)

                servers.start(vm)

            except:

                m.resolve_commissions\

    def test_task_after(self, mrapi):

        return

_pithos_backend_pool = \

    PithosBackendPool(

        settings.PITHOS_BACKEND_POOL_SIZE,

        service_token=settings.CYCLADES_SERVICE_TOKEN,

        astakosclient_poolsize=settings.CYCLADES_ASTAKOSCLIENT_POOLSIZE,

        db_connection=settings.BACKEND_DB_CONNECTION,

                               FloatingIP)

from synnefo.settings import (CYCLADES_SERVICE_TOKEN as ASTAKOS_TOKEN,

from astakosclient import AstakosClient

from astakosclient.errors import AstakosClientException, QuotaLimit

from functools import wraps

import logging

log = logging.getLogger(__name__)

DEFAULT_SOURCE = 'system'

RESOURCES = [

    "cyclades.vm",

    def get(cls):

        if cls._object is None:

            cls._object = AstakosClient(

                use_pool=True,

                retry=3,

                logger=log)

    qh = Quotaholder.get()

    try:

    except QuotaLimit as e:

        msg, details = render_overlimit_exception(e)

        raise faults.OverLimit(msg, details=details)

        reject = []

    qh = Quotaholder.get()

    if strict:

        failed = response["failed"]

def get_quotaholder_pending():

    qh = Quotaholder.get()

    return pending_serials

from synnefo.quotas.util import (get_db_holdings, get_quotaholder_holdings,

                                 transform_quotas)

from snf_django.management.utils import pprint_table

class Command(BaseCommand):

                     % datetime.now())

                request["provisions"] = map(create_provision, unsynced)

                try:

                except quotas.QuotaLimit:

                    write("Reconciling failed because a limit has been "

                          "reached. Use --force to ignore the check.\n")

from django.db.models import Sum, Count, Q

from synnefo.db.models import VirtualMachine, Network, FloatingIP

def get_db_holdings(user=None):

    Returns quotas for all users, unless a single user is specified.

    """

    qh = Quotaholder.get()

def transform_quotas(quotas):

#

import synnefo.cyclades_settings as cyclades

from synnefo.lib import join_urls

from synnefo.lib.services import get_public_endpoint as endpoint

BASE_PATH = cyclades.BASE_PATH

if not BASE_PATH.startswith("/"):

GLANCE_URL = endpoint(cyclades_services, 'image', 'v1.0').rstrip('/')

COMPUTE_URL = endpoint(cyclades_services, 'compute', 'v2.0').rstrip('/')

USERDATA_URL = endpoint(cyclades_services, 'cyclades_userdata', '').rstrip('/')

USER_CATALOG_URL = join_urls(ACCOUNT_URL, 'user_catalogs')

FEEDBACK_URL = join_urls(ACCOUNT_URL, 'feedback')

LOGOUT_REDIRECT = LOGIN_URL

        Main entry point for a request-response process.

        """

        def view(request, *args, **kwargs):

            if not request.user_uniq:

                return HttpResponse(status=401)

            self = cls(*initargs, **initkwargs)

    Response to generate private/public RSA key pair

    """

    if request.method != "POST":

        return http.HttpResponseNotAllowed(["POST"])