Produits Entr'ouvert » w.c.s.

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'

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')

@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)