Produits Entr'ouvert » Hobo

hobo-agent ALL=(wcs-au-quotidien)NOPASSWD:/usr/sbin/wcsctl -f /etc/wcs/wcs-au-quotidien.cfg hobo_notify -

hobo-agent ALL=(authentic-multitenant)NOPASSWD:/usr/bin/authentic2-multitenant-manage hobo_notify -

hobo-agent ALL=(combo)NOPASSWD:/usr/bin/combo-manage hobo_notify -

hobo-agent ALL=(passerelle)NOPASSWD:/usr/bin/passerelle-manage hobo_notify -

hobo-agent ALL=(fargo)NOPASSWD:/usr/bin/fargo-manage hobo_notify -

# Celery configuration

BROKER_URL = 'amqp://'

BROKER_TASK_EXPIRES = 120

import json

from django.db.models.signals import post_save, post_delete

from django.db.models import Q

from django.conf import settings

from django_rbac.utils import get_role_model

from hobo.agent.common import notify_agents

from authentic2.utils import to_list

from authentic2.saml.models import LibertyProvider

def get_ou(role_or_through):

    if hasattr(role_or_through, 'ou'):

        return role_or_through.ou

    else:

        return role_or_through.role.ou

def get_audience(role_or_through):

    ou = get_ou(role_or_through)

    if ou:

        qs = LibertyProvider.objects.filter(ou=ou)

    else:

        qs = LibertyProvider.objects.filter(ou__isnull=True)

    return list(qs.values_list('entity_id', flat=True))

def get_related_roles(role_or_through):

    ou = get_ou(role_or_through)

    Role = get_role_model()

    qs = Role.objects.filter(admin_scope_id__isnull=True) \

        .prefetch_related('attributes')

    if ou:

        qs = qs.filter(ou=ou)

    else:

        qs = qs.filter(ou__isnull=True)

    for role in qs:

        role.emails = []

        role.emails_to_members = False

        for attribute in role.attributes.all():

            if attribute.name in ('emails', 'emails_to_members') and attribute.kind == 'json':

                setattr(role, attribute.name, json.loads(attribute.value))

    return qs

def notify_roles(sender, instance, **kwargs):

    notify_agents({

        '@type': 'provision',

        'audience': get_audience(instance),

        'full': True,

        'objects': [

            {

                '@type': 'role',

                'uuid': role.uuid,

                'name': role.name,

                'slug': role.slug,

                'description': role.description,

                'emails': role.emails,

                'emails_to_members': role.emails_to_members,

            } for role in get_related_roles(instance)

        ]

    })

    def ready(self):

        Role = get_role_model()

        post_save.connect(notify_roles, Role)

        post_delete.connect(notify_roles, Role)

        post_save.connect(notify_roles, Role.members.through)

        post_delete.connect(notify_roles, Role.members.through)

        settings.A2_MANAGER_ROLE_FORM_CLASS = 'hobo.agent.authentic2.role_forms.RoleForm'

# Translation of hobo

# Copyright (C) 2015 Entr'ouvert

# This file is distributed under the same license as the hobo package.

# Benjamin Dauvergne <bdauvergne@entrouvert.com>, 2015

#

msgid ""

msgstr ""

"Project-Id-Version: hobo 0\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2015-06-11 15:06+0200\n"

"PO-Revision-Date: 2014-03-24 19:31+0100\n"

"Last-Translator: Benjamin Dauvergne <bdauvergne@entrouvert.com>\n"

"Language: French\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=2; plural=(n > 1);\n"

#: management/commands/hobo_deploy.py:148

#: management/commands/import-wcs-roles.py:49

msgid "Superuser"

msgstr "Super-utilisateur"

#: role_forms.py:23

#, python-brace-format

msgid "Item {0} is invalid: {1}"

msgstr "L'élément {0} est invalide: {1}"

#: role_forms.py:62

msgid "Emails"

msgstr "Courriels"

#: role_forms.py:65

msgid "Emails to members"

msgstr "Propager les courriels à tous les utilisateurs ayant ce rôle"

import json

from django import forms

from django.core import validators

from django.core.exceptions import ValidationError

from django.utils.translation import ugettext_lazy as _

from authentic2.a2_rbac.models import RoleAttribute, Role

from authentic2.validators import EmailValidator

from authentic2.manager.forms import RoleEditForm

class ListValidator(object):

    def __init__(self, item_validator):

        self.item_validator = item_validator

    def __call__(self, value):

        for i, item in enumerate(value):

            try:

                self.item_validator(item)

            except ValidationError, e:

                raise ValidationError(

                    _('Item {0} is invalid: {1}') % (i, e.args[0]))

class CommaSeparatedInput(forms.TextInput):

    def _format_value(self, value):

        return u', '.join(value)

class CommaSeparatedCharField(forms.Field):

    widget = CommaSeparatedInput

    def __init__(self, dedup=True, max_length=None, min_length=None, *args,

                 **kwargs):

        self.dedup = dedup

        self.max_length = max_length

        self.min_length = min_length

        item_validators = kwargs.pop('item_validators', [])

        super(CommaSeparatedCharField, self).__init__(*args, **kwargs)

        for item_validator in item_validators:

            self.validators.append(ListValidator(item_validator))

    def to_python(self, value):

        if value in validators.EMPTY_VALUES:

            return []

        value = [item.strip() for item in value.split(',') if item.strip()]

        if self.dedup:

            value = list(set(value))

        return value

    def clean(self, value):

        value = self.to_python(value)

        self.validate(value)

        self.run_validators(value)

        return value

class RoleForm(RoleEditForm):

    emails = CommaSeparatedCharField(label=_('Emails'),

                                           item_validators=[EmailValidator()])

    emails_to_members = forms.BooleanField(required=False,

                                           label=_('Emails to members'))

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

        instance = kwargs.get('instance')

        if instance:

            fields = Role._meta.get_all_field_names()

            initial = kwargs.setdefault('initial', {})

            role_attributes = RoleAttribute.objects.filter(role=instance,

                                                           kind='json')

            for role_attribute in role_attributes:

                if role_attribute.name in fields:

                    continue

                initial[role_attribute.name] = json.loads(role_attribute.value)

        super(RoleForm, self).__init__(*args, **kwargs)

    def save(self, commit=True):

        fields = Role._meta.get_all_field_names()

        assert commit

        instance = super(RoleForm, self).save(commit=commit)

        for field in self.cleaned_data:

            if field in fields:

                continue

            value = json.dumps(self.cleaned_data[field])

            ra, created = RoleAttribute.objects.get_or_create(

                role=instance, name=field, kind='json',

                defaults={'value': value})

            if not created and ra.value != value:

                ra.value = value

                ra.save()

        instance.save()

        return instance

from celery import Celery

from kombu.common import Broadcast

from django.conf import settings

from django.db import connection

def notify_agents(data):

    '''Send notifications to all other tenants'''

    notification = {

        'tenant': connection.get_tenant().domain_url,

        'data': data,

    }

    with Celery('hobo', broker=settings.BROKER_URL) as app:

        app.conf.update(

            CELERY_TASK_SERIALIZER='json',

            CELERY_ACCEPT_CONTENT=['json'],

            CELERY_RESULT_SERIALIZER='json',

            CELERY_QUEUES=(Broadcast('broadcast_tasks'), )

        )

        # see called method in hobo.agent.worker.celery

        app.send_task('hobo-notify',

                      (notification,),

                      expires=settings.BROKER_TASK_EXPIRES,

                      queue='broadcast_tasks')

from django.core.management.base import BaseCommand

class Command(BaseCommand):

    def handle(self, *args, **kwargs):

        pass

@app.task(name='hobo-notify', bind=True, acks_late=True)

def hobo_notify(self, notification):

    assert 'tenant' in notification

    assert 'data' in notification

    services.notify(notification['data'])

import sys

    @classmethod

    def is_for_us(cls, url):

        patterns = settings.AGENT_HOST_PATTERNS.get(cls.service_id)

        parsed_url = urllib2.urlparse.urlsplit(url)

    @classmethod

    def notify(cls, data):

        for audience in data.get('audience', []):

            if cls.is_for_us(audience):

                break

        else:

            return

        cmd = cls.service_manage_cmd + ' hobo_notify -'

        try:

            cmd_process = subprocess.Popen(cmd, shell=True, stdin=subprocess.PIPE,

                                           stdout=subprocess.PIPE, stderr=subprocess.PIPE)

        except OSError:

            return

        stdout, stderr = cmd_process.communicate(input=json.dumps(data))

        if cmd_process.returncode != 0:

            raise RuntimeError('command "%s" failed: %r %r' % (cmd, stdout, stderr))

        if not service_obj.is_for_us(service_obj.base_url):

def notify(data):

    for klassname, service in globals().items():

        if not hasattr(service, 'service_id'):

            continue

        service.notify(data)