Produits Entr'ouvert » Hobo

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

from django.db.models import Q

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

    is 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 qs.values_list('entity_id', flat=True)

def get_related_roles(role_or_through)

    Role = get_role_model()

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

    if ou:

        return qs.filter(Q(ou=ou)|Q(ou__isnull=True))

    else:

        return qs.filter(ou__isnull=True)

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,

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

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, data):

    services.notify(data)

    @classmethod

    def notify(cls, data):

        cmd = settings.service_manage_cmd + ' hobo_notify -'

        try:

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

                                           stdout=subprocess.PIPE)

        except OSError:

            return

        cmd_process.communicate(input=json.dumps(data))

        if cmd_process.returncode != 0:

            raise RuntimeError('command "%s" failed' % what)

def notify(data):

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

        if not hasattr(service, 'notify'):

            continue

        service.notify(data)