Synnefo

def index(request):

    raise Http404

    url(r'^$', index),

    url(r'^stats$', views.get_stats),

)

        else:

            try:

                network_id = int(pool)

                raise faults.BadRequest("Invalid pool ID.")

            if network is None:

                raise faults.ItemNotFound("Pool '%s' does not exist." % pool)

            if address is None:

                # If address is not available, check that it belongs to the

                # same user

                elif not network.nics.filter(ipv4=address,

                        msg = "Address '%s' is already in use" % address

                        raise faults.Conflict(msg)

        floating_ip = FloatingIP.objects.create(ipv4=address, network=network,

            raise CommandError("Can not create network."

                               " No connectivity link or mode")

        netinfo = {

        if dry_run:

            self.stdout.write("Creating network:\n")

            self.stdout.write("Trying to connect network to backend '%s'\n" %

                              backend)

            jobs = create_network(network=network, backend=backend,

            self.stdout.write("Successfully issued jobs: %s\n" %

                              ",".join(jobs))

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

import ipaddr

from base64 import b64encode, b64decode

from hashlib import sha256

from logging import getLogger

from random import choice

from string import digits, lowercase, uppercase

from Crypto.Cipher import AES

from django.http import HttpResponse

from django.template.loader import render_to_string

from django.utils import simplejson as json

from django.db.models import Q

from snf_django.lib.api import faults

                               FloatingIP)

from synnefo.db.pools import EmptyPool

from synnefo.plankton.utils import image_backend

from synnefo.settings import MAX_CIDR_BLOCK

    # Check that network size is allowed!

    if not validate_network_size(network.prefixlen):

        raise faults.OverLimit(message="Unsupported network size",

    # Check that gateway belongs to network

    if gateway:

def render_meta(request, meta, status=200):

    if request.serialization == 'xml':

        data = render_to_string('meta.xml', dict(key=key, val=val))

    else:

        data = json.dumps(dict(meta=meta))

    """Verify that a a list of personalities is well formed"""

    if len(personality) > settings.MAX_PERSONALITY:

        raise faults.OverLimit("Maximum number of personalities"

    for p in personality:

        # Verify that personalities are well-formed

        try:

                  "href": join_urls(IMAGES_PLANKTON_URL, str(image_id))})

    return links

def start_action(vm, action, jobId):

    vm.action = action

    vm.backendjobid = jobId

from logging import getLogger

from django.http import HttpResponse

from django.template.loader import render_to_string

from django.utils import simplejson as json

VERSION_2_0 = {

    "links": [

        {

        },

    ],

}

MEDIA_TYPES = [

    {

    },

    {

    }

]

DESCRIBED_BY = [

    {

    },

    {

    }

]

# Minutes between reconciliations

RECONCILIATION_MIN = 30

astakos_proxy = partial(proxy, proxy_base=BASE_ASTAKOS_PROXY_PATH,

                        target_base=ASTAKOS_BASE_URL)

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

    (prefix_pattern(PLANKTON_PREFIX), include('synnefo.plankton.urls')),

    (prefix_pattern(COMPUTE_PREFIX), include('synnefo.api.urls')),

    (prefix_pattern(ADMIN_PREFIX), include('synnefo.admin.urls')),

)

    (prefix_pattern(UI_PREFIX), include('synnefo.ui.urls')),

    (prefix_pattern(HELPDESK_PREFIX), include('synnefo.helpdesk.urls')),

)

    astakos_proxy = partial(proxy, proxy_base=BASE_ASTAKOS_PROXY_PATH,

                            target_base=ASTAKOS_BASE_URL)

        (prefix_pattern(ASTAKOS_VIEWS_PREFIX), astakos_proxy),

    )

    proxy_patterns += api_patterns(

# Patch astakosclient directly, otherwise it will not see any customization

#astakos_services = deepcopy(vanilla_astakos_services)

CUSTOMIZE_ASTAKOS_SERVICES = \

astakos_services = deepcopy(vanilla_astakos_services)

fill_endpoints(astakos_services, ASTAKOS_BASE_URL)

                                                 disk=Sum("flavor__disk"))

    vm_active_resources = \

        vms.values("userid")\

                   Q(operstate="ERROR"))\

           .annotate(active_ram=Sum("flavor__ram"),

                     active_cpu=Sum("flavor__cpu"))

except ImportError:

    import pkgutil

    __path__ = pkgutil.extend_path(__path__, __name__)

        except ValueError:

            raise faults.BadRequest("Invalid JSON data")

    else:

def prefix_pattern(prefix):