Synnefo

# or implied, of GRNET S.A.

from django import http

from django.utils import simplejson as json

from django.core.urlresolvers import reverse

from django.http import HttpResponse

from snf_django.lib.astakos import get_user

from django.conf import settings

class View(object):

    """

        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)

            if request.method.upper() in ['POST', 'PUT']:

                # Expect json data

                    try:

                        data = json.loads(data)

                    except ValueError:

                else:

            try:

            except ValidationError, e:

                # specific response for validation errors

        else:

            allowed_methods = [m for m in self.method_names if hasattr(self, m)]

    """

    url_name = None

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

        self.url_name = url_name

        return super(JSONRestView, self).__init__(*args, **kwargs)

            raise http.Http404

    def GET(self, request, data, *args, **kwargs):

    def PUT(self, request, data, *args, **kwargs):

        instance = self.instance()

        return self.model.objects.all()

    def GET(self, request, data, *args, **kwargs):

    def POST(self, request, data, *args, **kwargs):

        instance = self.model()

        self.update_instance(instance, data, self.exclude_fields)

        instance.full_clean()

        instance.save()

class UserResourceView(ResourceView):

    """

    def queryset(self):

        return super(UserResourceView,

class UserCollectionView(CollectionView):

    Filter collection queryset for request user entries

    """

    def queryset(self):

    def POST(self, request, data, *args, **kwargs):

        instance = self.model()

        instance.user = request.user_uniq

        instance.full_clean()

        instance.save()

# or implied, of GRNET S.A.

from django import http

from django.utils import simplejson as json

from django.conf import settings

import base64

class PublicKeyPairResourceView(rest.UserResourceView):

    model = PublicKeyPair

    exclude_fields = ["user"]

class PublicKeyPairCollectionView(rest.UserCollectionView):

    model = PublicKeyPair

    exclude_fields = ["user"]

SSH_KEY_LENGTH = getattr(settings, 'USERDATA_SSH_KEY_LENGTH', 2048)

def generate_key_pair(request):

    """

    Response to generate private/public RSA key pair

        raise Exception("Application does not support ssh keys generation")

    if PublicKeyPair.user_limit_exceeded(request.user):

    # generate RSA key

    from Crypto import Random

    Random.atfork()

    # get PEM string

    pem = exportKey(key, 'PEM')

    data = {'private': pem, 'public': public}

    return http.HttpResponse(json.dumps(data), mimetype="application/json")

def download_private_key(request):

    """

    Return key contents

    response['Content-Disposition'] = 'attachment; filename=%s' % name

    response.write(data)

    return response

from django.conf import settings

from django.utils.translation import gettext_lazy as _

from django.http import HttpResponse

from django.utils.translation import get_language

from django.utils import simplejson as json

from django.template.loader import render_to_string

from django.core.urlresolvers import reverse

from django.template import RequestContext

from synnefo.util.version import get_component_version

UPDATE_INTERVAL = getattr(settings, "UI_UPDATE_INTERVAL", 5000)

CHANGES_SINCE_ALIGNMENT = getattr(settings, "UI_CHANGES_SINCE_ALIGNMENT", 0)

UPDATE_INTERVAL_INCREASE = getattr(settings, "UI_UPDATE_INTERVAL_INCREASE", 500)

UPDATE_INTERVAL_FAST = getattr(settings, "UI_UPDATE_INTERVAL_FAST", 2500)

UPDATE_INTERVAL_MAX = getattr(settings, "UI_UPDATE_INTERVAL_MAX", 10000)

QUOTAS_UPDATE_INTERVAL = getattr(settings, "UI_QUOTAS_UPDATE_INTERVAL", 10000)

# predefined values settings

SUGGESTED_FLAVORS_DEFAULT = {}

SUGGESTED_FLAVORS = getattr(settings, "VM_CREATE_SUGGESTED_FLAVORS",

                            SUGGESTED_FLAVORS_DEFAULT)

SUGGESTED_ROLES = getattr(settings, "VM_CREATE_SUGGESTED_ROLES",

                          SUGGESTED_ROLES_DEFAULT)

IMAGE_ICONS = settings.IMAGE_ICONS

SUPPORT_SSH_OS_LIST = getattr(settings, "UI_SUPPORT_SSH_OS_LIST",)

OS_CREATED_USERS = getattr(settings, "UI_OS_DEFAULT_USER_MAP")

# UI behaviour settings

DELAY_ON_BLUR = getattr(settings, "UI_DELAY_ON_BLUR", True)

UPDATE_HIDDEN_VIEWS = getattr(settings, "UI_UPDATE_HIDDEN_VIEWS", False)

SKIP_TIMEOUTS = getattr(settings, "UI_SKIP_TIMEOUTS", 1)

# Additional settings

VM_NAME_TEMPLATE = getattr(settings, "VM_CREATE_NAME_TPL", "My {0} server")

VM_HOSTNAME_FORMAT = getattr(settings, "UI_VM_HOSTNAME_FORMAT",

if isinstance(VM_HOSTNAME_FORMAT, basestring):

MAX_SSH_KEYS_PER_USER = getattr(settings, "USERDATA_MAX_SSH_KEYS_PER_USER")

SYSTEM_IMAGES_OWNERS = getattr(settings, "UI_SYSTEM_IMAGES_OWNERS", {})

CUSTOM_IMAGE_HELP_URL = getattr(settings, "UI_CUSTOM_IMAGE_HELP_URL", None)

# MEDIA PATHS

# extensions

ENABLE_GLANCE = getattr(settings, 'UI_ENABLE_GLANCE', True)

GLANCE_API_URL = getattr(settings, 'UI_GLANCE_API_URL', '/glance')

# network settings

DEFAULT_NETWORK_SUBNETS = ['10.0.0.0/24', '192.168.1.1/24']

AUTOMATIC_NETWORK_RANGE_FORMAT = getattr(settings,

                                         'UI_AUTOMATIC_NETWORK_RANGE_FORMAT',

GROUP_PUBLIC_NETWORKS = getattr(settings, 'UI_GROUP_PUBLIC_NETWORKS', True)

USER_CATALOG_URL = getattr(settings, 'UI_USER_CATALOG_URL', '/user_catalogs')

FEEDBACK_POST_URL = getattr(settings, 'UI_FEEDBACK_POST_URL', '/feedback')

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

def template(name, request, context):

    template_path = os.path.join(os.path.dirname(__file__), "templates/")

    current_template = template_path + name + '.html'

    t = loader.get_template(current_template)

    media_context = {

    }

    context.update(media_context)

    return HttpResponse(t.render(RequestContext(request, context)))

def home(request):

    context = {'timeout': TIMEOUT,

               'project': '+nefo',

               'user_catalog_url': json.dumps(USER_CATALOG_URL),

               'feedback_post_url': json.dumps(FEEDBACK_POST_URL),

               'translate_uuids': json.dumps(TRANSLATE_UUIDS),

               'update_interval': UPDATE_INTERVAL,

               'update_interval_increase': UPDATE_INTERVAL_INCREASE,

               'update_interval_fast': UPDATE_INTERVAL_FAST,

               'update_interval_max': UPDATE_INTERVAL_MAX,

               'changes_since_alignment': CHANGES_SINCE_ALIGNMENT,

               'handle_window_exceptions': json.dumps(HANDLE_WINDOW_EXCEPTIONS),

               'skip_timeouts': json.dumps(SKIP_TIMEOUTS),

               'vm_name_template': json.dumps(VM_NAME_TEMPLATE),

               'support_ssh_os_list': json.dumps(SUPPORT_SSH_OS_LIST),

               'os_created_users': json.dumps(OS_CREATED_USERS),

               'userdata_keys_limit': json.dumps(MAX_SSH_KEYS_PER_USER),

               'image_deleted_size_title': json.dumps(IMAGE_DELETED_SIZE_TITLE),

               'network_suggested_subnets': json.dumps(NETWORK_SUBNETS),

               'network_available_types': json.dumps(NETWORK_TYPES),

               'network_strict_destroy': json.dumps(NETWORK_STRICT_DESTROY),

               'group_public_networks': json.dumps(GROUP_PUBLIC_NETWORKS),

               'vm_hostname_format': json.dumps(VM_HOSTNAME_FORMAT)

    return template('home', request, context)

def machines_console(request):

    context = {'host': host, 'port': port, 'password': password,

               'machine': machine, 'host_ip': host_ip, 'host_ip_v6': host_ip_v6}

    return template('machines_console', request, context)

def user_quota(request):

    try:

        get_user(request, settings.ASTAKOS_URL, usage=True)

        # try to mimic astakos response using cyclades quota settings

        networks_limit_for_user = \

            settings.NETWORKS_USER_QUOTA.get(request.user_uniq,

        vms_limit_for_user = \

            settings.VMS_USER_QUOTA.get(request.user_uniq,

    return HttpResponse(response, mimetype="application/json")

def js_tests(request):

    return template('tests', request, {})

we suggest the use of <a target="_blank"

after its creation.</span>""")

href="http://en.wikipedia.org/wiki/Secure_Shell">SSH Protocol</a>.

Open an ssh client such as PuTTY and type the following:""")

established using Remote Desktop. Click on the following link, and if asked

open it using "Remote Desktop Connection".

after its creation.</span>""")

# info/subinfo for all os combinations

#

# provided to the user when needed

CONNECT_PROMPT_MESSAGES = {

    'linux': {

    },

    'windows': {

    },

}

for k, v in APPEND_CONNECT_PROMPT_MESSAGES.iteritems():

    CONNECT_PROMPT_MESSAGES[k].update(v)

# domain template string

DOMAIN_TPL = "%s%%s" % DOMAIN_PREFIX

def machines_connect(request):

    server_id = request.GET.get('srv', 0)

    username = request.GET.get('username', None)

    domain = request.GET.get("domain", DOMAIN_TPL % int(server_id))

            extra_rdp_content = EXTRA_RDP_CONTENT(server_id, ip_address,

                                                  hostname, username)

        else:

                    'ip_address': ip_address,

                    'hostname': hostname,

                    'user': username

        rdp_context = {

        }

        rdp_file_data = render_to_string("synnefo-windows.rdp", rdp_context)

            link_title = ssh_message(server_id, ip_address, hostname, username)

        else:

            link_title = ssh_message % {

        if (operating_system != "windows"):

            link_url = None

        else:

            link_title = _("Remote desktop to %s") % ip_address

                    reverse("ui_machines_connect"), ip_address,

        # try to find a specific message

        try:

            subinfo = CONNECT_PROMPT_MESSAGES[host_os][operating_system][1]

        except KeyError:

            subinfo = ""

        response_object = {

    return response

import logging

from urlparse import urlparse

from django.http import (

from django.utils.http import urlencode

from django.views.decorators.csrf import csrf_exempt

        status = int(response.status)

        return HttpResponse(data, status=status)

@csrf_exempt

def delegate_to_feedback_service(request):

    token = request.META.get('HTTP_X_AUTH_TOKEN')

    return proxy(

        request, USER_FEEDBACK_URL, headers=headers, body=request.raw_post_data)

@csrf_exempt

def delegate_to_user_catalogs_service(request):

    token = request.META.get('HTTP_X_AUTH_TOKEN')