Produits Entr'ouvert » Mandaye

Quick installation

------------------

Install at least Python >=2.5 and pip in your system.

For example with Debian or a Debian based distribution::

    sudo apt-get install python python-pip

Then install virtualenv ::

   pip install virtualenv

Create your virtualenv activate it::

    virtualenv mandaye

    source mandaye/bin/activate

    pip install -U pip

Install mandaye::

    $ tar xfvz mandaye-VERSION.tar.gz

    $ cd mandaye-VERSION

    $ pip install -r requirements.txt

First step is to create a mandaye project::

  $ mandaye_admin.py --newproject

from mandaye.config.backend import ManagerIDPUser, ManagerSPUser,\

        ManagerServiceProvider

    config.encrypt_sp_password = False

        To use this feature you muste set encrypt_sp_password to True

        encrypt_sp_password to True in your configuration and

            if config.encrypt_sp_password:

    def _save_association(self, env, unique_id, post_values):

        unique_id: idp uinique id

        sp_login = post_values[self.form_values['username_field']]

        if config.encrypt_sp_password:

        service_provider = ManagerServiceProvider.get_or_create(self.site_name)

        idp_user = ManagerIDPUser.get_or_create(unique_id)

        sp_user = ManagerSPUser.get_or_create(sp_login, post_values,

                idp_user, service_provider)

        sp_user.login = sp_login

        sp_user.post_values = post_values

        sp_user.idp_user = idp_user

        sp_user.last_connection = datetime.now()

        sp_user.service_provider = service_provider

        ManagerSPUser.save()

        env['beaker.session']['unique_id'] = unique_id

        env['beaker.session'][self.site_name] = sp_user.id

        unique_id = env['beaker.session'].get('unique_id')

            if not unique_id:

                self._save_association(env, unique_id, post_values)

    def _login_sp_user(self, sp_user, env, condition, values):

        """ Log in sp user

        if not sp_user.login:

        post_values = copy.deepcopy(sp_user.post_values)

        if config.encrypt_sp_password:

            sp_user.last_connection = datetime.now()

            ManagerSPUser.save()

            env['beaker.session'][self.site_name] = sp_user.id

        # Specific method to get current idp unique id

        unique_id = self.get_current_unique_id(env)

        if not unique_id:

        env['beaker.session']['unique_id'] = unique_id

        logger.debug('User %s successfully login' % env['beaker.session']['unique_id'])

        idp_user = ManagerIDPUser.get(unique_id)

        service_provider = ManagerServiceProvider.get(self.site_name)

        sp_user = ManagerSPUser.get_last_connected(idp_user, service_provider)

        if not sp_user:

            logger.debug('User %s is not associate' % env['beaker.session']['unique_id'])

        return self._login_sp_user(sp_user, env, condition, values)

        unique_id = env['beaker.session']['unique_id']

        service_provider = ManagerServiceProvider.get(self.site_name)

        idp_user = ManagerServiceProvider.get(unique_id)

        sp_user = ManagerSPUser.get_last_connected(idp_user, service_provider)

        if not sp_user:

        return self._login_sp_user(sp_user, env, 'response.code==302', values)

        sp_user = ManagerSPUser.get_by_id(id)

        if sp_user:

            ManagerSPUser.delete(sp_user)

    def get_current_unique_id(self, env):

        """ Return the current Vincennes unique id

        env['beaker.session']['unique_id'] = unique_id

class DefaultManagerIDPUser:

    @staticmethod

    def get(unique_id, idp_id='default'):

        pass

    @staticmethod

    def create(unique_id, idp_id='default'):

        pass

    @staticmethod

    def get_or_create(unique_id, idp_id='default'):

        pass

    @staticmethod

    def delete(idp_user):

        pass

    @staticmethod

    def save(idp_user):

        pass

class DefaultManagerSPUser:

    @staticmethod

    def get(login, idp_user, service_provider):

        pass

    @staticmethod

    def get_by_id(id):

        pass

    @staticmethod

    def get_last_connected(idp_user, service_provider):

        pass

    @staticmethod

    def create(login, post_values, idp_user, service_provider):

        pass

    @staticmethod

    def get_or_create(login, post_values, idp_user, service_provider):

        pass

    @staticmethod

    def delete(sp_user):

        pass

    @staticmethod

    def save(sp_user):

        pass

class DefaultServiceProvider:

    @staticmethod

    def get(name):

        pass

    @staticmethod

    def create(name):

        pass

    @staticmethod

    def get_or_create(name):

        pass

    @staticmethod

    def delete(service_provider):

        pass

    @staticmethod

    def save(service_provider):

        pass

from datetime import datetime

from mandaye.db import sql_session

from mandaye.models import IDPUser, SPUser, ServiceProvider

class ManagerIDPUserSQL:

    @staticmethod

    def get(unique_id, idp_id='default'):

        idp_user = sql_session().query(IDPUser).\

                filter_by(unique_id=unique_id,

                        idp_id='default')

        if len(idp_user) > 1:

            logger.critical('ManagerIDPUserSQL.get %s not unique' % unique_id)

            raise MandayeException(

                    'ManagerIDPUserSQL.get : %s is not unique' % unique_id)

        if idp_user:

            return idp_user.first()

        else:

            return None

    @staticmethod

    def create(unique_id, idp_id='default'):

        idp_user = IDPUser(

                    unique_id=unique_id,

                    idp_id=idp_id)

        sql_session().add(idp_user)

        return idp_user

    @staticmethod

    def get_or_create(unique_id, idp_id='default'):

        if ManagerIDPUserSQL.get(**kwargs):

            return user

        else:

            return ManagerIDPUserSQL.create(**kwargs)

    @staticmethod

    def delete(idp_user):

        sql_session().delete(idp_user)

        sql_session().commit()

    @staticmethod

    def save():

        sql_session().commit()

class ManagerSPUserSQL:

    @staticmethod

    def get(login, idp_user, service_provider):

        sp_user = sql_session().query(SPPUser).\

                join(IDPUser).\

                join(ServiceProvider).\

                filter_by(login=login,

                        idp_user=idp_user,

                        service_provider=service_provider)

        if sp_user:

            return sp_user.first()

        else:

            return None

    @staticmethod

    def get_by_id(id):

        return sql_session().query(SPUser).\

                filter(id==id).first()

    @staticmethod

    def get_last_connected(idp_user, service_provider):

        return sql_session().query(SPPUser).\

                join(IDPUser).\

                join(ServiceProvider).\

                filter(idp_user=idp_user).\

                filer(service_provider=service_provider).\

                order_by(SPUser.last_connection.desc()).\

                first()

    @staticmethod

    def get_sp_users(idp_unique_id, service_provider_name):

        return sql_session().query(SPUser).\

                    join(IDPUser).\

                    join(ServiceProvider).\

                    filter(IDPUser.unique_id==idp_unique_id).\

                    filter(ServiceProvider.name==service_provider_name).\

                    order_by(SPUser.last_connection.desc()).\

                    all()

    @staticmethod

    def create(login, post_values, idp_user, service_provider):

        sp_user = SPUser(

                    login=login,

                    post_values=post_values,

                    idp_id=idp_id,

                    service_provider = service_provider

                    )

        logger.info('New association: %s with %s on site %s' % \

                    (login, idp_user.unique_id, service_provider.name))

        sql_session().add(sp_user)

        sql_session().commit()

        return idp_user

    @staticmethod

    def get_or_create(login, post_values, idp_user, service_provider):

        sp_user = ManagerSPUserSQL.get(login, idp_user, service_provider)

        if sp_user:

            return sp_user

        else:

            return ManagerSPUserSQL.create(login, post_values,

                    idp_user, service_provider)

    @staticmethod

    def all():

        return sql_session().query(SPUser).all()

    @staticmethod

    def delete(sp_user):

        logger.debug('Disassociate account %s' % sp_user.login)

        sql_session().delete(sp_user)

        sql_session().commit()

    @staticmethod

    def save():

        sql_session().commit()

class ManagerServiceProviderSQL:

    @staticmethod

    def get(name):

        sp = sql_session().query(ServiceProvider).\

                filter_by(name=name)

        if sp:

            return sp.first()

        else:

            return None

    @staticmethod

    def create(name):

        logger.info('Add %s service provider into the database' % name)

        sp = ServiceProvider(name=name)

        sql_session().add(sp)

        sql_session().commit()

        return sp

    @staticmethod

    def get_or_create(name):

        sp = ManagerServiceProviderSQL.get(name)

        if sp:

            return sp

        else:

            return ManagerServiceProviderSQL.create(name)

    @staticmethod

    def delete(service_provider):

        logger.debug('Delete service provider %s' % service_provider.name)

        sql_session().delete(service_provider)

        sql_session().commit()

    @staticmethod

    def save():

        sql_session().commit()

ManagerServiceProvider = ManagerServiceProviderSQL

ManagerSPUser = ManagerSPUserSQL

ManagerServiceProvider = ManagerServiceProviderSQL

# Database configuration

# rfc 1738 http://rfc.net/rfc1738.html

db_url = 'sqlite:///test.db'

# Default local backend

import mandaye.backends.sql

backend = mandaye.backends.sql

# Encrypt service provider passwords with a secret

encrypt_sp_password = False

from mandaye.config.backend import ManagerSPUser

        return ManagerSPUser.get_by_id(env['beaker.session'].get(site_name))

    unique_id = env['beaker.session'].get('unique_id')

            sp_users = ManagerSPUser.get_sp_users(unique_id,

                    values.get('site_name'))

            for sp_user in sp_users:

                accounts[sp_user.id] = sp_user.login

            if env['beaker.session'].get('unique_id'):

            login = env['beaker.session'].get('unique_id')

            login = env['beaker.session'].get('unique_id')

import collections

import json

from sqlalchemy import Column, Integer, String, DateTime

from sqlalchemy import ForeignKey

from sqlalchemy.ext.declarative import declarative_base

from sqlalchemy.ext.mutable import Mutable

from sqlalchemy.orm import column_property, relationship, backref

from sqlalchemy.types import TypeDecorator, VARCHAR

Base = declarative_base()

class JSONEncodedDict(TypeDecorator):

    "Represents an immutable structure as a json-encoded string."

    impl = VARCHAR

    def process_bind_param(self, value, dialect):

        if value is not None:

            value = json.dumps(value)

        return value

    def process_result_value(self, value, dialect):

        if value is not None:

            value = json.loads(value)

        return value

class MutationDict(Mutable, dict):

    @classmethod

    def coerce(cls, key, value):

        """ Convert plain dictionaries to MutationDict. """

        if not isinstance(value, MutationDict):

            if isinstance(value, dict):

                return MutationDict(value)

            # this call will raise ValueError

            return Mutable.coerce(key, value)

        else:

            return value

    def __setitem__(self, key, value):

        """ Detect dictionary set events and emit change events. """

        dict.__setitem__(self, key, value)

        self.changed()

    def __delitem__(self, key):

        """ Detect dictionary del events and emit change events. """

        dict.__delitem__(self, key)

        self.changed()

MutationDict.associate_with(JSONEncodedDict)

class ServiceProvider(Base):

    __tablename__ = 'service_provider'

    id = Column(Integer, primary_key=True)

    name = Column(String(50), unique=True, nullable=False)

    def __init__(self, name):

        self.name = name

    def __repr__(self):

        return "<ServiceProvider('%s')>" % (self.name)

class IDPUser(Base):

    __tablename__ = 'idp_user'

    id = Column(Integer, primary_key=True)

    # Nameid, pseudo, email, ...

    unique_id = Column(String(150), nullable=False)

    # Entityid

    idp_id = Column(String(150), nullable=False)

    sp_users = relationship("SPUser", backref=backref('idp_user'))

    def __init__(self, unique_id=None, idp_id=None, sp_users=None):

        self.unique_id = unique_id

        self.idp_id = idp_id

        self.sp_users = sp_users

    def __repr__(self):

        return "<IDPUser %d '%s'>" % (self.id, self.unique_id)

class SPUser(Base):

    __tablename__ = 'sp_user'

    id = Column(Integer, primary_key=True)

    post_values = Column(JSONEncodedDict, nullable=False)

    creation_date = Column(DateTime, default=datetime.now(), nullable=False)

    last_connection = Column(DateTime, default=datetime.now())

    idp_user_id = Column(Integer, ForeignKey('idp_user.id'))

    service_provider_id = Column(Integer, ForeignKey('service_provider.id'),

            nullable=False)

    service_provider = relationship("ServiceProvider", backref=backref('users'))

    def __init__(self, post_values=None):

        self.post_values = post_values

    def __repr__(self):

        return "<SPUser '%d'>" % (self.id)

    ServiceProvider.__table__.create(migrate_engine)

    SPUser.__table__.create(migrate_engine)

    IDPUser.__table__.create(migrate_engine)

    ServiceProvider.__table__.drop(migrate_engine)

    SPUser.__table__.drop(migrate_engine)

    IDPUser.__table__.drop(migrate_engine)

""" This models is used if you are using form replay authentification

"""

Base = declarative_base()

class ServiceProvider(Base):

    __tablename__ = 'service_provider'

        return "<ServiceProvider('%s')>" % (self.name)

class IDPUser(Base):

    __tablename__ = 'idp_user'

    id = Column(Integer, primary_key=True)

    # Nameid, pseudo, email, ...

    unique_id = Column(String(150), nullable=False)

    # Entityid

    idp_id = Column(String(150), nullable=False)

    sp_users = relationship("SPUser", backref=backref('idp_user'))

    def __init__(self, unique_id=None, idp_id=None, sp_users=None):

        self.unique_id = unique_id

        self.idp_id = idp_id

        self.sp_users = sp_users

        return "<IDPUser %d '%s'>" % (self.id, self.unique_id)

class SPUser(Base):

    __tablename__ = 'sp_user'

    post_values = Column(JSONEncodedDict, nullable=False)

    idp_user_id = Column(Integer, ForeignKey('idp_user.id'))

    service_provider_id = Column(Integer, ForeignKey('service_provider.id'),

            nullable=False)

    service_provider = relationship("ServiceProvider", backref=backref('users'))

    def __init__(self, post_values=None):

        return "<SPUser '%d'>" % (self.id)

                email.sent('Mandaye internal server error %s' % exception,

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"

        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">

  <head>

    <meta http-equiv="Content-type" content="text/html; charset=utf-8" /> 

    <meta http-equiv="Content-Language" content="fr-fr" /> 

    <title>1er connexion</title> 

  </head>

  <h3>1er connexion</h3>

  % if error_msg:

  <p>${error_msg}</p>

  % elif description:

  <p>${description}</p>

  % endif

  <form action="${action}" method="post" accept-charset="utf-8">

    <div>

      <label for="username">${username_label}</label>

      <input type="text" name="username" value="" id="username" />

    </div>

    <div>

      <label for="password">${password_label}</label>

      <input type="password" name="password" value="" id="password" />

    </div>

    <p><input type="submit" value="Enregistrer"></p>

  </form>

</html>

<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN"> 

<html>

  <head> 

    <title>${title}</title> 

  </head>

  <body> 

    <h1>${title}</h1> 

    <p>${body}</p>

  </body>

</html> 

    usage = "usage: %prog --newproject|--createdb|--cryptpwd"

    parser.add_option("--newproject",

            dest="cryptpwd",

            default=False,

            action="store_true",

            help="Crypt external password in Mandaye's database"

            )

        from mandaye.config.backend import ManagerSPUserSQL

        for user in ManagerSPUserSQL.all():

        ManagerSPUserSQL.save()

beaker>=1.6

poster>=0.8

pycrypto>=2.0

lxml>=2.0

xtraceback>=0.3

sqlalchemy>=0.7,<0.8

static

#!/usr/bin/env python

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

""" Script to launch mandaye with gunicorn server

"""

import sys

import os

from mandaye.log import logger

from gunicorn.app.wsgiapp import WSGIApplication

class WSGIApplication(WSGIApplication):

    def init(self, parser, opts, args):

        self.cfg.set("default_proc_name", "mandaye.wsgi:application")

        self.app_uri = "mandaye.wsgi:application"

        sys.path.insert(0, os.getcwd())

def main():

    """ The ``gunicorn`` command line runner for launcing Gunicorn with

    generic WSGI applications.

    """

    logger.info('Mandaye start')

    WSGIApplication("%prog [OPTIONS]").run()

if __name__ == "__main__":

    main()

from sys import version

install_requires=[

          'beaker>=1.6',

          'gunicorn>=0.13',

          'mako>=0.3',

          'poster>=0.8',

          'pycrypto>=2.0',

          'sqlalchemy>=0.6',

          'sqlalchemy-migrate>=0.7.2',

          'lxml>=2.0',

          'xtraceback>=0.3',

          'static',

]

if version < '2.7':

    install_requires.append('importlib')

      scripts=['mandaye_admin.py', 'mandaye_migrate.py'],

      install_requires=install_requires