Produits Entr'ouvert » Mandaye

include mandaye/alembic.ini

import os

from importlib import import_module

from mandaye import global_config

from mandaye.exceptions import ImproperlyConfigured

ENVIRONMENT_VARIABLE = "MANDAYE_CONFIG_MODULE"

config = None

if os.environ.has_key(ENVIRONMENT_VARIABLE):

    try:

        mod = import_module(os.environ[ENVIRONMENT_VARIABLE])

    except ImportError, e:

        raise ImproperlyConfigured('Error importing config %s: "%s"' % (os.environ[ENVIRONMENT_VARIABLE], e))

    config = mod

else:

    config = global_config

import os

_PROJECT_PATH = os.path.join(os.path.dirname(__file__), '..')

# Choose storage

# mandaye.backends.ldap_back or mandaye.backends.sql

storage_backend = "mandaye.backends.sql"

## SQL Backend config

# Database configuration

# http://docs.sqlalchemy.org/en/rel_0_8/core/engines.html

# rfc 1738 https://tools.ietf.org/html/rfc1738

# dialect+driver://username:password@host:port/database

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

## LDAP Backend config

ldap_url = 'ldap://127.0.0.1'

ldap_bind_dn = 'cn=admin,dc=acompany,dc=org'

ldap_bind_password = 'MyPassword'

ldap_base_dn = 'ou=mandaye,dc=acompany,dc=org'

# urllib2 debug mode

debug = False

# Log configuration

LOGGING = {

        'version': 1,

        'disable_existing_loggers': True,

        'formatters': {

            'console': {

                'format': '%(asctime)s %(levelname)s %(message)s',

                'datefmt': '%H:%M:%S',

                },

            'syslog': {

                'format': '%(name)s %(levelname)s %(uuid)s %(message)s',

                }

            },

        'handlers': {

            'console': {

                'level': 'DEBUG',

                'class': 'logging.StreamHandler',

                'formatter': 'console'

                },

            'syslog': {

                'level': 'INFO',

                'class': 'entrouvert.logging.handlers.SysLogHandler',

                'formatter': 'syslog',

                'address': '/dev/log',

                'max_length': 999,

                },

            },

            'loggers': {

                '': {

                    'handlers': ['console'],

                    'level': 'DEBUG',

                    'propagate': False,

                    },

                'mandaye': {

                    'handlers': ['console', 'syslog'],

                    'level': 'DEBUG',

                    'propagate': False,

                    },

                },

            }

# Template directory

template_directory = os.path.join(_PROJECT_PATH, 'mandaye/templates')

templates_directories = []

# Configuration directory

config_root = os.path.join(_PROJECT_PATH, 'conf.d')

# Static path

static_url = '/mandaye/static'

# Static folder

static_root = os.path.join(_PROJECT_PATH, 'mandaye/static')

# Data dir

data_dir = os.path.join(_PROJECT_PATH, 'data')

# Skel root

skel_root = os.path.join(_PROJECT_PATH, 'mandaye/skel')

# Raven Sentry configuration

raven_dsn = None

# Email notification configuration

email_notification = False

email_prefix='[Mandaye]'

smtp_host = 'localhost'

smtp_port = 25

email_from = 'traceback@entrouvert.com'

email_to = ['admin@localhost']

# Template vars

template_vars = {}

# Use long traceback with xtraceback

use_long_trace = True

# Ask Mandaye to auto decompress a response message

# Decompress response only if you load a filter

auto_decompress = True

# Ask mandaye to add a toolbar

mandaye_toolbar = True

mandaye_offline_toolbar = False

# Authentic 2 auto connection

a2_auto_connection = False

# Encrypt service provider passwords with a secret

# You should install pycypto to use this feature

encrypt_sp_password = False

# Must be a 16, 24, or 32 bytes long

encrypt_secret = ''

alembic_cfg = os.path.join(_PROJECT_PATH, 'mandaye/alembic.ini')

alembic_script_path = os.path.join(_PROJECT_PATH, 'mandaye/alembic')

# supported authentification

authentifications = {

        'saml2': 'mandaye.auth.SAML2Auth'

        }

# supported mappers

mappers = {}

# beaker session configuration

session_opts = {

        'session.type': 'file',

        'session.cookie_expires': True,

        'session.timeout': 3600,

        'session.data_dir': '/var/tmp/beaker',

        'session.path': '/'

        }

# Needed if ssl is activated

ssl = False

keyfile = ''

certfile = ''

if raven_dsn:

    LOGGING['handlers']['sentry'] = {

            'level': 'ERROR',

            'class': 'raven.handlers.logging.SentryHandler',

            'dsn': raven_dsn,

            }

    LOGGING['loggers']['']['handlers'].append('sentry')

import logging

import os

from ConfigParser import SafeConfigParser

from mandaye.exceptions import ImproperlyConfigured

# get configuration files from :

# 1. default-settings.ini from source code

# 2. os.environ.get('SETTINGS_INI') if it exists

#    else /etc/mandaye-cam/config.ini

#         and then /etc/mandaye-cam/local-config.ini

BASE_DIR = os.path.dirname(os.path.abspath(__file__))

SETTINGS_INI = (os.path.join(BASE_DIR, 'default-config.ini'),)

if os.environ.get('SETTINGS_INI'):

    SETTINGS_INI += (os.environ.get('SETTINGS_INI'),)

else:

    ETC_DIR = os.path.join('/', 'etc', 'mandaye-cam')

    SETTINGS_INI += (

        os.path.join(ETC_DIR, 'config.ini'),

        os.path.join(ETC_DIR, 'local-config.ini')

    )

config = SafeConfigParser()

config.read(SETTINGS_INI)

## SQL Backend config

# Database configuration

# http://docs.sqlalchemy.org/en/rel_0_7/core/engines.html

# rfc 1738 https://tools.ietf.org/html/rfc1738

# dialect+driver://username:password@host:port/database

db_url = config.get('database', 'url')

## LDAP Backend config

ldap_url = config.get('ldap', 'url')

ldap_bind_dn = config.get('ldap', 'base_dn')

ldap_bind_password = config.get('ldap', 'bind_password')

ldap_base_dn = config.get('ldap', 'base_dn')

debug = config.getboolean('debug', 'debug')

# Log configuration

LOGGING = {{

        'version': 1,

        'disable_existing_loggers': True,

        'formatters': {{

            'console': {{

                'format': '%(asctime)s %(levelname)s %(message)s',

                'datefmt': '%H:%M:%S',

                }},

            'file': {{

                'format': '%(asctime)s %(levelname)s %(uuid)s %(message)s',

                'datefmt': '%Y-%m-%d %H:%M:%S'

                }}

            }},

        'handlers': {{

            'console': {{

                'level': 'DEBUG',

                'class': 'logging.StreamHandler',

                'formatter': 'console'

                }},

            'syslog': {{

                'level': 'DEBUG',

                'class': 'entrouvert.logging.handlers.SysLogHandler',

                'formatter': 'file',

                'address': '/dev/log'

                }},

            }},

        'loggers': {{

            '': {{

                'handlers': ['console'],

                'level': 'INFO',

                'propagate': False,

                }},

            'mandaye': {{

                'handlers': ['console', 'syslog'],

                'level': 'INFO',

                'propagate': False,

                }},

            'cam': {{

                'handlers': ['console', 'syslog'],

                'level': 'INFO',

                'propagate': False,

                }},

            }},

        }}

if config.getboolean('debug', 'log_debug'):

    LOGGING['loggers']['']['level'] = 'DEBUG'

    LOGGING['loggers']['mandaye']['level'] = 'DEBUG'

    LOGGING['loggers']['cam']['level'] = 'DEBUG'

## PATH

# Configuration directory

config_root = config.get('dirs', 'config_root')

# Templates directories

templates_directories = []

if config.get('dirs', 'templates_directories'):

    templates_directories = config.get('dirs', 'templates_directories').split(' ')

templates_directories.append(os.path.join(BASE_DIR, 'templates'))

# Static url

static_url = config.get('dirs', 'static_url')

# Static folder

static_root = config.get('dirs', 'static_root')

# Data dir

data_dir = config.get('dirs', 'data_dir')

# template vars

template_vars = {{}}

if config.has_section('template_vars'):

    for option in config.options('template_vars'):

        template_vars[option] = config.get('template_vars', option)

# Supported authentification

authentifications = {{

    'saml2': 'mandaye.auth.saml2.SAML2Auth'

}}

# sp mappers

mappers = {{

    'linuxfr': '{project_name}.mappers.linuxfr_example',

}}

# Raven Sentry configuration

raven_dsn = config.get('debug', 'sentry_dsn')

# Email notification configuration

email_notification = config.getboolean('email', 'notification')

email_prefix = config.get('email', 'prefix')

smtp_host = config.get('email', 'smtp_host')

smtp_port = config.getint('email', 'smtp_port')

email_from = config.get('email', 'from')

email_to = config.get('email', 'to').split()

# Use long traceback with xtraceback

use_long_trace = config.getboolean('debug', 'use_long_trace')

# Ask Mandaye to auto decompress a response message

# Decompress response only if you load a filter

auto_decompress = config.getboolean('mandaye', 'auto_decompress')

# Ask mandaye to add a toolbar with Mandaye's links

mandaye_toolbar = config.getboolean('mandaye', 'toolbar')

mandaye_offline_toolbar = config.getboolean('mandaye', 'offline_toolbar')

# Authentic 2 auto connection

a2_auto_connection = config.getboolean('mandaye', 'a2_auto_connection')

# Choose storage (sql or ldap)

if config.get('mandaye', 'storage_backend') == 'sql':

    storage_backend = "mandaye.backends.sql"

elif config.get('mandaye', 'storage_backend') == 'ldap':

    storage_backend = "mandaye.backends.ldap_back"

else:

    ImproperlyConfigured('Storage backend must be sql or ldap')

# Encrypt service provider passwords with a secret

# You should install pycypto to use this feature

encrypt_sp_password = config.getboolean('mandaye', 'encrypt_sp_password')

# Must be a 15, 24, or 32 bytes long

encrypt_secret = config.get('mandaye', 'encrypt_secret')

session_type = config.get('session', 'type')

if session_type not in ('file', 'dbm', 'memory', 'memcached'):

    raise ImproperlyConfigured('Sesssion type %r not supported' % session_type)

if session_type == 'memcached':

    session_type = 'ext:memcached'

# Beaker session configuration

session_opts = {{

    'session.type': session_type,

    'session.url': config.get('session', 'url'),

    'session.cookie_expires': config.getboolean('session', 'cookie_expires'),

    'session.timeout': config.getint('session', 'timeout'),

    'session.data_dir': config.get('session', 'data_dir'),

    'session.path': '/'

}}

# Import local config

try:

    from cam.local_config import *

except ImportError, e:

    if not 'local_config' in e.args[0]:

        raise ImproperlyConfigured('Error while importing "local_config.py"')

prefix: [Mandaye CAM]

os.environ.setdefault("MANDAYE_CONFIG_MODULE", "{project_name}.config")

from {project_name} import config

## Virtual hosts configuration

hosts = {{

        'linuxfrsaml.local:8000': [

            {{

                'path': r'/',

                'target': 'http://linuxfr.org',

                'mapping': '{project_name}.configs.linuxfr_saml_example.linuxfr_mapping'

                }},

            ],

        }}

## SQL Backend config

# http://docs.sqlalchemy.org/en/rel_0_7/core/engines.html

# rfc 1738 https://tools.ietf.org/html/rfc1738

# dialect+driver://username:password@host:port/database

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

## Logging configuration

debug = False

os.environ['MANDAYE_CONFIG_MODULE'] = '{project_name}.config'

import base64

from mandaye import config

from mandaye.log import logger

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

    parser.add_option("--cryptpwd",

            dest="cryptpwd",

            default=False,

            action="store_true",

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

            )

def encrypt_pwd(pwd):

    from Crypto.Cipher import AES

    logger.debug("Encrypt password")

    enc_pwd = pwd

    if config.encrypt_secret:

        try:

            cipher = AES.new(config.encrypt_secret, AES.MODE_CFB)

            enc_pwd = cipher.encrypt(pwd)

            enc_pwd = base64.b64encode(enc_pwd)

        except Exception, e:

            if config.debug:

                traceback.print_exc()

            logger.warning('Password encrypting failed %s' % e)

    else:

        logger.warning("You must set a secret to use pwd encryption")

    return enc_pwd

        from mandaye import global_config

        alembic_cfg = Config(global_config.alembic_cfg)

        alembic_cfg.set_main_option("script_location", global_config.alembic_script_path)

    if options.cryptpwd:

        from mandaye.backends.default import ManagerSPUser

        for user in ManagerSPUser.all():

            user.password = encrypt_pwd(user.password)

        ManagerSPUser.save()

os.environ.setdefault("MANDAYE_CONFIG_MODULE", "{project_name}.config")

from mandaye.log import logger

    logger.info('{project_name} reverse-proxy start')

from mandaye import config, global_config

templates_directories = config.templates_directories + [global_config.template_directory]

from mandaye import config, global_config

        skel = global_config.skel_root