Synnefo

snf-manage test aai admin api db helpdesk invitations logic userdata --settings=synnefo.settings.test

snf-manage test aai admin api db helpdesk logic userdata --settings=synnefo.settings.test

[

    {

        "model": "db.SynnefoUser",

        "pk": 1,

        "fields": {

            "name": "testdbuser",

            "realname" :"test db user",

            "uniq" :"test@synnefo.gr",

            "auth_token": "46e427d657b20defe352804f0eb6f8a2",

            "auth_token_created": "2011-04-07 09:17:14",

            "auth_token_expires": "2015-04-07 09:17:14",

            "type": "STUDENT",

            "created": "2011-02-06"

   	    }

    }

]

# Copyright 2011 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

#   1. Redistributions of source code must retain the above copyright

#      notice, this list of conditions and the following disclaimer.

#

#  2. Redistributions in binary form must reproduce the above copyright

#     notice, this list of conditions and the following disclaimer in the

#     documentation and/or other materials provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

# ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

# SUCH DAMAGE.

#

# The views and conclusions contained in the software and documentation are

# those of the authors and should not be interpreted as representing official

# policies, either expressed or implied, of GRNET S.A.

from django.conf import settings

from django.http import HttpResponse, HttpResponseRedirect

from django.utils.cache import patch_vary_headers

from synnefo.db.models import SynnefoUser

from synnefo.aai.shibboleth import Tokens, register_shibboleth_user

import time

DONT_CHECK = getattr(settings, "AAI_SKIP_AUTH_URLS", ['/api'])

class SynnefoAuthMiddleware(object):

    def process_request(self, request):

        for path in DONT_CHECK:

            if request.path.startswith(path):

                return

        # Special case for testing purposes, delivers the cookie for the

        # test user on first access

        if settings.BYPASS_AUTHENTICATION and \

           request.GET.get('test') is not None:

            try:

                u = SynnefoUser.objects.get(

                    auth_token=settings.BYPASS_AUTHENTICATION_SECRET_TOKEN)

            except SynnefoUser.DoesNotExist:

                raise Exception("No user found with token matching "

                                "BYPASS_AUTHENTICATION_SECRET_TOKEN.")

            return self._redirect_shib_auth_user(user = u)

        token = None

        # Try to find token in a cookie

        token = request.COOKIES.get('X-Auth-Token', None)

        # Try to find token in request header

        if not token:

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

        if token:

            # token was found, retrieve user from backing store

            try:

                user = SynnefoUser.objects.get(auth_token=token)

            except SynnefoUser.DoesNotExist:

                return HttpResponseRedirect(settings.LOGIN_URL)

            # check user's auth token validity

            if (time.time() -

                time.mktime(user.auth_token_expires.timetuple())) > 0:

                # the user's token has expired, prompt to re-login

                return HttpResponseRedirect(settings.LOGIN_URL)

            request.user = user

            return

        # token was not found but user authenticated by Shibboleth

        if Tokens.SHIB_EPPN in request.META and \

           Tokens.SHIB_SESSION_ID in request.META:

            try:

                user = SynnefoUser.objects.get(uniq=request.META[Tokens.SHIB_EPPN])

                return self._redirect_shib_auth_user(user)

            except SynnefoUser.DoesNotExist:

                if register_shibboleth_user(request.META):

                    user = SynnefoUser.objects.get(uniq=request.META[Tokens.SHIB_EPPN])

                    return self._redirect_shib_auth_user(user)

                else:

                    return HttpResponseRedirect(settings.LOGIN_URL)

        if settings.TEST and 'TEST-AAI' in request.META:

            return HttpResponseRedirect(settings.LOGIN_URL)

        if request.path.endswith(settings.LOGIN_URL):

            # avoid redirect loops

            return

        else:

            # no authentication info found in headers, redirect back

            return HttpResponseRedirect(settings.LOGIN_URL)

    def process_response(self, request, response):

        # Tell proxies and other interested parties that the request varies

        # based on X-Auth-Token, to avoid caching of results

        patch_vary_headers(response, ('X-Auth-Token',))

        return response

    def _redirect_shib_auth_user(self, user):

        expire_fmt = user.auth_token_expires.strftime('%a, %d-%b-%Y %H:%M:%S %Z')

        response = HttpResponse()

        response.set_cookie('X-Auth-Token', value=user.auth_token,

                            expires=expire_fmt, path='/')

        response['X-Auth-Token'] = user.auth_token

        response['Location'] = settings.APP_INSTALL_URL

        response.status_code = 302

        return response

def add_url_exception(url):

    if not url in DONT_CHECK:

        DONT_CHECK.append(url)

# Copyright 2011 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

#   1. Redistributions of source code must retain the above copyright

#      notice, this list of conditions and the following disclaimer.

#

#  2. Redistributions in binary form must reproduce the above copyright

#     notice, this list of conditions and the following disclaimer in the

#     documentation and/or other materials provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

# ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

# SUCH DAMAGE.

#

# The views and conclusions contained in the software and documentation are

# those of the authors and should not be interpreted as representing official

# policies, either expressed or implied, of GRNET S.A.

# Business Logic for working with sibbolleth users

from synnefo.logic import users

class Tokens:

    # these are mapped by the Shibboleth SP software

    SHIB_EPPN = "eppn" # eduPersonPrincipalName

    SHIB_NAME = "Shib-InetOrgPerson-givenName"

    SHIB_SURNAME = "Shib-Person-surname"

    SHIB_CN = "Shib-Person-commonName"

    SHIB_DISPLAYNAME = "Shib-InetOrgPerson-displayName"

    SHIB_EP_AFFILIATION = "Shib-EP-Affiliation"

    SHIB_SESSION_ID = "Shib-Session-ID"

class NoUniqueToken(BaseException):

    def __init__(self, msg):

        self.msg = msg

class NoRealName(BaseException):

    def __init__(self, msg):

        self.msg = msg

def register_shibboleth_user(tokens):

    """Registers a Shibboleth user using the input hash as a source for data."""

    if Tokens.SHIB_DISPLAYNAME in tokens:

        realname = tokens[Tokens.SHIB_DISPLAYNAME]

    elif Tokens.SHIB_CN in tokens:

        realname = tokens[Tokens.SHIB_CN]

    elif Tokens.SHIB_NAME in tokens and Tokens.SHIB_SURNAME in tokens:

        realname = tokens[Tokens.SHIB_NAME] + ' ' + tokens[Tokens.SHIB_SURNAME]

    else:

        raise NoRealName("Authentication does not return the user's name")

    try:

        affiliation = tokens[Tokens.SHIB_EP_AFFILIATION]

    except KeyError:

        affiliation = 'member'

    try:

        eppn = tokens[Tokens.SHIB_EPPN]

    except KeyError:

        raise NoUniqueToken("Authentication does not return a unique token")

    if affiliation == 'student':

        users.register_student(realname, '' , eppn)

    else:

        # this includes faculty but also staff, alumni, member, other, ...

        users.register_professor(realname, '' , eppn)

    return True

# Copyright 2011 GRNET S.A. All rights reserved.

#

# Redistribution and use in source and binary forms, with or without

# modification, are permitted provided that the following conditions

# are met:

#

#   1. Redistributions of source code must retain the above copyright

#      notice, this list of conditions and the following disclaimer.

#

#  2. Redistributions in binary form must reproduce the above copyright

#     notice, this list of conditions and the following disclaimer in the

#     documentation and/or other materials provided with the distribution.

#

# THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

# ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

# SUCH DAMAGE.

#

# The views and conclusions contained in the software and documentation are

# those of the authors and should not be interpreted as representing official

# policies, either expressed or implied, of GRNET S.A.

# Provides automated tests for aai module. The tests

from django.test import TestCase

from django.test.client import Client

from django.conf import settings

from synnefo.db.models import SynnefoUser

from datetime import datetime, timedelta

from synnefo.aai.shibboleth import Tokens

class AaiTestCase(TestCase):

    fixtures = ['users', 'api_test_data', 'auth_test_data']

    apibase = '/api/v1.1'

    def setUp(self):

        self.client = Client()

    def test_shibboleth_correct_request(self):

        """test request that should succeed and register a user

        """

        response = self.client.get('/index.html', {},

                                   **{Tokens.SHIB_NAME: 'Jimmy',

                                      Tokens.SHIB_EPPN: 'jh@gmail.com',

                                      Tokens.SHIB_CN: 'Jimmy Hendrix',

                                      Tokens.SHIB_SESSION_ID: '123321',

                                      'TEST-AAI' : 'true'})

        user = None

        try:

            user = SynnefoUser.objects.get(uniq = "jh@gmail.com")

        except SynnefoUser.DoesNotExist:

            self.assertNotEqual(user, None)

        self.assertNotEqual(user, None)

        self.assertEquals(response.status_code, 302)

        self.assertEquals(response['Location'], settings.APP_INSTALL_URL)

        self.assertTrue('X-Auth-Token' in response)

        self.assertEquals(response['X-Auth-Token'], user.auth_token)

        #self.assertNotEquals(response.cookies['X-Auth-Token'].find(user.auth_token), -1)

    def test_shibboleth_no_uniq_request(self):

        """test a request with no unique field

        """

        response = self.client.get('/index.html', {},

                               **{Tokens.SHIB_NAME: 'Jimmy',

                                  Tokens.SHIB_CN: 'Jimmy Hendrix',

                                  'TEST-AAI': 'true'})

        self._test_redirect(response)

    def test_shibboleth_expired_token(self):

        """ test request from expired token

        """

        user = SynnefoUser.objects.get(uniq="test@synnefo.gr")

        self.assertNotEqual(user.auth_token_expires, None)

        user.auth_token_expires = datetime.now()

        user.save()

        response = self.client.get('/index.html', {},

                               **{'X-Auth-Token': user.auth_token,

                                  'TEST-AAI': 'true'})

        self._test_redirect(response)

    def test_shibboleth_redirect(self):

        """ test redirect to Sibboleth page

        """

        response = self.client.get('/index.html', {}, **{'TEST-AAI': 'true'})

        self._test_redirect(response)

    def test_shibboleth_auth(self):

        """ test authentication with X-Auth-Token

        """

        user = SynnefoUser.objects.get(uniq="test@synnefo.gr")

        response = self.client.get('/index.html', {},

                               **{'X-Auth-Token': user.auth_token,

                                  'TEST-AAI': 'true'})

        self.assertTrue(response.status_code, 200)

        self.assertTrue('Vary' in response)

        self.assertTrue('X-Auth-Token' in response['Vary'])

    def test_auth_cookie(self):

        user = SynnefoUser.objects.get(uniq = "test@synnefo.gr")

        self.client.cookies['X-Auth-Token'] = user.auth_token

        response = self.client.get('/', {},

                                   **{'X-Auth-Token': user.auth_token,

                                      'TEST-AAI' : 'true'})

        self.assertTrue(response.status_code, 200)

        self.assertTrue('Vary' in response)

        self.assertTrue('X-Auth-Token' in response['Vary'])

    def _test_redirect(self, response):

        self.assertEquals(response.status_code, 302)

        self.assertTrue('Location' in response)

        self.assertTrue(response['Location'].startswith(settings.LOGIN_URL))

from synnefo.db import models

    server = models.VirtualMachine.objects.get(id=server_id)

@requires_admin

def users_info(request, user_id):

    user = models.SynnefoUser.objects.get(id=user_id)

    reply = {

    	'name': user.name,

    	'ref': reverse('synnefo.admin.views.users_info', args=(user_id,))}

    return HttpResponse(json.dumps(reply), content_type='application/json')

function append_user() {

	append_item('append-user', '/admin/api/users/');

}

	append_user();

	$('.append-user').change(function() {

		append_user();

	});

          <input class="small append-user" id="image-owner" name="owner" value="{{ image.owner.id }}" type="text" />

      <td>{% if image.owner %}<a href="{% url synnefo.admin.views.users_info image.owner.id %}">{{ image.owner.name }}</a>{% endif %}

      </td>

      <input class="small append-user" id="image-owner" name="owner" value="{{ image.owner.id }}" type="text" />

      <td><a href="{% url synnefo.admin.views.users_info server.owner.id %}">{{ server.owner.name }}</a></td>

{% extends "base.html" %}

{% block body %}

<form action="{% url synnefo.admin.views.users_modify user.id %}" method="post">

  <div class="clearfix">

    <label for="user-id">ID</label>

    <div class="input">

      <span class="uneditable-input" id="user-id">{{ user.id }}</span>

    </div>

  </div>

  <div class="clearfix">

    <label for="user-name">Name</label>

    <div class="input">

      <input class="medium" id="user-name" name="name" value="{{ user.name }}" type="text" />

    </div>

  </div>

  <div class="clearfix">

    <label for="user-realname">Real Name</label>

    <div class="input">

      <input class="large" id="user-realname" name="realname" value="{{ user.realname }}" type="text" />

    </div>

  </div>

  <div class="clearfix">

    <label for="user-uniq">Uniq</label>

    <div class="input">

      <input class="large" id="user-uniq" name="uniq" value="{{ user.uniq }}" type="text" />

    </div>

  </div>

  <div class="clearfix">

    <label for="user-type">Type</label>

    <div class="input">

      <select class="medium" id="user-type" name="type">

        {% for type in types %}

        <option{% ifequal type user.type %} selected{% endifequal %}>{{ type }}</option>

        {% endfor %}

      </select>

    </div>

  </div>

  <div class="clearfix">

    <label for="user-state">State</label>

    <div class="input">

      <select class="medium" id="user-state" name="state">

        {% for state in states %}

        <option{% ifequal state user.state %} selected{% endifequal %}>{{ state }}</option>

        {% endfor %}

      </select>

    </div>

  </div>

  <div class="clearfix">

    <label for="user-created">Created</label>

    <div class="input">

      <span class="uneditable-input" id="user-created">{{ user.created }}</span>

    </div>

  </div>

  <div class="clearfix">

    <label for="user-updated">Updated</label>

    <div class="input">

      <span class="uneditable-input" id="user-updated">{{ user.updated }}</span>

    </div>

  </div>

  <div class="actions">

    <button type="submit" class="btn primary">Save Changes</button>

    <button type="reset" class="btn">Reset</button>

  </div>

</form>

{% endblock body %}

{% extends "base.html" %}

{% block body %}

<table class="zebra-striped id-sorted">

  <thead>

    <tr>

      <th>ID</th>

      <th>Name</th>

      <th>Real Name</th>

      <th>Uniq</th>

      <th>Type</th>

      <th>State</th>

      <th>Updated</th>

    </tr>

  </thead>

  <tbody>

    {% for user in users %}

    <tr>

      <td><a href="{% url synnefo.admin.views.users_info user.id %}">{{ user.id }}</a></td>

      <td><a href="{% url synnefo.admin.views.users_info user.id %}">{{ user.name }}</a></td>

      <td>{{ user.realname }}</td>

      <td>{{ user.uniq }}</td>

      <td>{{ user.type }}</td>

      <td>{{ user.state }}</td>

      <td>{{ user.updated }}</td>

    </tr>

    {% endfor %}

  </tbody>

</table>

{% endblock body %}

    (r'^/users/?$', 'users_list'),

    (r'^/users/(\d+)/?$', 'users_info'),

    (r'^/users/(\d+)/modify/?$', 'users_modify'),

    (r'^/users/(\d+)/delete/?$', 'users_delete'),

    stats['users'] = models.SynnefoUser.objects.count()

        owner_id = request.POST.get('owner') or None

        image.owner = owner_id and models.SynnefoUser.objects.get(id=owner_id)

    owner_id = request.POST.get('owner') or None

    image.owner = owner_id and models.SynnefoUser.objects.get(id=owner_id)

    vm_id = request.POST.get('sourcevm') or None

@requires_admin

def users_list(request):

    all_states = set(x[0] for x in models.SynnefoUser.ACCOUNT_STATE)

    default = all_states - set(['DELETED'])

    filters = get_filters(request, 'users_filters', all_states, default)

    users = models.SynnefoUser.objects.all()

    for state in all_states - filters:

        users = users.exclude(state=state)

    html = render('users_list.html', 'users',

                    users=users.order_by('id'),

                    all_states=sorted(all_states),

                    filters=filters)

    return HttpResponse(html)

@requires_admin

def users_info(request, user_id):

    user = models.SynnefoUser.objects.get(id=user_id)

    types = [x[0] for x in models.SynnefoUser.ACCOUNT_TYPE]

    if not user.type:

        types = [''] + types

    states = [x[0] for x in models.SynnefoUser.ACCOUNT_STATE]

    html = render('users_info.html', 'users',

                    user=user, types=types, states=states)

    return HttpResponse(html)

@requires_admin

def users_modify(request, user_id):

    user = models.SynnefoUser.objects.get(id=user_id)

    user.name = request.POST.get('name')

    user.realname = request.POST.get('realname')

    user.uniq = request.POST.get('uniq')

    user.type = request.POST.get('type')

    user.state = request.POST.get('state')

    user.save()

    log.info('User %s modified User %s', request.user.name, user.name)

    return redirect(users_info, user.id)

@requires_admin

def users_delete(request, user_id):

    user = models.SynnefoUser.objects.get(id=user_id)

    user.delete()

    log.info('User %s deleted User %s', request.user.name, user.name)

    return redirect(users_list)

            "owner": 1,

            "owner": 1,

            "owner": 1,

            "owner": 1,

            "owner": 1,

            "owner" : 1,

from django.http import HttpResponse

from synnefo.db.models import SynnefoUser

from django.utils.cache import patch_vary_headers

import time

class ApiAuthMiddleware(object):

    auth_token = "X-Auth-Token"

    auth_user  = "X-Auth-User"

    auth_key   = "X-Auth-Key"

        if not request.path.startswith('/api/') :

            return

        token = None

        # Try to find token in a cookie

        token = request.COOKIES.get('X-Auth-Token', None)

        # Try to find token in request header

        if not token:

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

        if token:

            user = None

            # Retrieve user from DB or other caching mechanism

            try:

                user = SynnefoUser.objects.get(auth_token=token)

            except SynnefoUser.DoesNotExist:

                user = None

            # Check user's auth token

            if user and (time.time() -

                time.mktime(user.auth_token_expires.timetuple())) > 0:

                # The user's token has expired, re-login

                user = None

            request.user = user

            return

        # A Rackspace API authentication request

        if self.auth_user in request.META and \

           self.auth_key in request.META and \

           'GET' == request.method:

            # This is here merely for compatibility with the Openstack API.

            # All normal users should authenticate through Shibboleth. Admin

            # users or other selected users could use this as a bypass

            # mechanism

            user = SynnefoUser.objects\

                    .filter(name = request.META[self.auth_user]) \

                    .filter(uniq = request.META[self.auth_key])

            response = HttpResponse()

            if user.count() <= 0:

                response.status_code = 401

            else:

                response.status_code = 204

                response['X-Auth-Token'] = user[0].auth_token

                # TODO: set the following fields when we do have this info

                response['X-Server-Management-Url'] = ""

                response['X-Storage-Url'] = ""

                response['X-CDN-Management-Url'] = ""

            return response

        request['HTTP_X_AUTH_TOKEN'] = \

            settings.BYPASS_AUTHENTICATION_SECRET_TOKEN

                        "owner": 1,

def create_users(n=1):

    for i in range(n):

        SynnefoUser.objects.create(name='User %d' % i)

    owner = SynnefoUser.objects.all()[0]

            owner=owner)

    owner = SynnefoUser.objects.all()[0]

            owner=owner,

    USERS = 0

        create_users(self.USERS)

        if not image.public and image.owner != owner:

    'synnefo.aai',

    'synnefo.helpdesk',

        'synnefo.aai.middleware.SynnefoAuthMiddleware',

        'synnefo.api.middleware.ApiAuthMiddleware',

        'synnefo.helpdesk.middleware.HelpdeskMiddleware'

from synnefo.app_settings.default.aai import *

from synnefo.app_settings.default.helpdesk import *

# -*- coding: utf-8 -*-

from synnefo.util.entry_points import extend_list_from_entry_point

#

# AAI configuration

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

# Unauthenticated HTTP requests to the UI get redirected to this URL

LOGIN_URL = "/login"

# Set the expiration time of newly created auth tokens

# to be this many hours after their creation time.

AUTH_TOKEN_DURATION = 30 * 24

# Enable receiving a temporary auth token (using the ?test URL parameter) that

# bypasses the authentication mechanism.

#

# Make sure there is an actual user in the db whose token matches

# BYPASS_AUTHENTICATION_SECRET_TOKEN.

#

# WARNING, ACHTUNG, README, etc: DO NOT ENABLE THIS ON DEPLOYED VERSIONS!

#

BYPASS_AUTHENTICATION = False

BYPASS_AUTHENTICATION_SECRET_TOKEN = '5e41595e9e884543fa048e07c1094d74'

# Urls that bypass Shibboleth authentication

AAI_SKIP_AUTH_URLS = ['/api', '/plankton']

AAI_SKIP_AUTH_URLS = extend_list_from_entry_point(AAI_SKIP_AUTH_URLS, \

        'synnefo', 'web_skip_urls')

# -*- coding: utf-8 -*-

#

# Helpdesk application

#

# Duration for temporary auth tokens, created for impersonating a registered

# user by helpdesk staff.

HELPDESK_TOKEN_DURATION_MIN = 30

# IP addresses of the machines allowed to connect as help desk

HELPDESK_ALLOWED_IPS = ("127.0.0.1",)

    (r'^helpdesk/?', include('synnefo.helpdesk.urls')),

        "model": "db.SynnefoUser",

        "pk": 30000,

        "fields": {

            "name": "testdbuser",

            "realname" :"test db user",

            "uniq" :"test@synnefo.gr",

            "auth_token": "5e41595e9e884543fa048e07c1094d74",

            "auth_token_created": "2009-04-07 09:17:14",

            "auth_token_expires": "2015-04-07 09:17:14",

            "type": "STUDENT",

            "created": "2011-02-06"

   	    }

    },

    {

            "owner" : 30000

            "owner": 30000,

            "owner": 30000,

        "model": "db.Disk",

        "pk": 30000,

        "fields": {

            "name": "My_Music",

            "created": "2011-02-10 00:00:00",

            "size" : 20,

            "vm" : 30000,

            "owner" : 30000

        }

    },

    {

            "owner": 30000,

[

    {

        "model": "db.Disk",

        "pk": 1,

        "fields": {

            "name": "My_Music",

            "created": "2011-02-10 00:00:00",

            "updated": "2011-02-10 00:00:00",

            "size" : "20",

            "vm" : "1001",

            "owner" : "1"

        }

    }, 

    {

        "model": "db.Disk",

        "pk": 2,

        "fields": {

            "name": "My_Videos",

            "created": "2011-02-10 00:00:00",

            "updated": "2011-02-10 00:00:00",

            "size" : "300",

            "vm" : "1001",

            "owner" : "1"

        }

    } 

] 

            "owner": 1,

            "owner": 1,

            "owner": 1,

            "owner": 1,

            "owner": 1,

            "owner": 1,

            "owner": 1,

[

    {

        "model": "db.SynnefoUser",

        "pk": 1,

        "fields": {

            "name": "testdbuser",

            "realname" :"test db user",

            "uniq" :"test@synnefo.gr",

            "auth_token": "5e41595e9e884543fa048e07c1094d74",

            "auth_token_created": "2011-05-10",

            "auth_token_expires": "2015-05-10",

            "type": "ADMIN",

            "created": "2011-05-10"

   	    }

    },

    {

        "model": "db.SynnefoUser",

        "pk": 2,

        "fields": {

            "name": "helpdesk",

            "realname" :"HelpDesk user",

            "uniq" :"helpdesk@synnefo.grnet.gr",

            "auth_token": "cd7c3c159507515ac495c54bee3ff8d1",

            "auth_token_created": "2011-05-10",

            "auth_token_expires": "2015-05-10",

            "type": "HELPDESK",

            "created": "2011-05-10"

   	    }

    }

] 

            "owner": 1,

            "owner": 1,

            "owner": 1,

        "owner": 1,

            "owner": 1,

            "owner": 1,

        'db.debit': {

            'Meta': {'object_name': 'Debit'},

            'description': ('django.db.models.fields.TextField', [], {}),

            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),

            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['db.SynnefoUser']"}),

            'vm': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['db.VirtualMachine']"}),

            'when': ('django.db.models.fields.DateTimeField', [], {})

        },

            'charged': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2012, 1, 23, 13, 34, 33, 344061)'}),