clients.py

import logging
from django.contrib.auth.models import Group
from rest_framework import generics, views
from rest_framework.authentication import BasicAuthentication
from rest_framework.response import Response


from ..models.brokers import RabbitMQInstance
from ..models.serializers.webpage import DeploymentStateSerializer
from ..models.serializers.clients import RabbitMQInstanceSerializer
from ..models import models

LOGGER = logging.getLogger(__name__)


# authentication class for the client api
AUTHENTICATION_CLASSES = (BasicAuthentication, )


# The client fetches pending tasks
class DeploymentsView(generics.ListAPIView):
    authentication_classes = AUTHENTICATION_CLASSES
    serializer_class = DeploymentStateSerializer

    def get_queryset(self):
        return self.request.user.site.pending_tasks


# the client has to fetch the configuration (like services etc.) here
class ConfigurationView(views.APIView):
    authentication_classes = AUTHENTICATION_CLASSES

    def put(self, request):
        #services = request.data.get('services', None)
        group_to_services = request.data.get('group_to_services', None)

        # TODO check if client has new services
        #if services is not None:
        #    for service in services:
        #        pass

        if group_to_services is not None:
            for group_name, group_service_list in group_to_services.items():
                group = None
                try:
                    group = Group.objects.get(name=group_name)
                except Group.DoesNotExist:
                    LOGGER.info("Group %s does not exist. Creating it", group_name)
                    group = Group(
                        name=group_name,
                    )
                    group.save()

                for group_service in group_service_list:
                    name = group_service.get('name', None)
                    description = group_service.get('description', None)

                    service = None
                    try:
                        service = models.Service.objects.get(name=name)

                        # update description if needed
                        if service.description != description:
                            LOGGER.info("Updating service description")
                            service.description = description
                            service.save()

                        # test if service has the group
                        try:
                            service.groups.get(name=group_name)
                        except Group.DoesNotExist:
                            service.groups.add(group)


                    except models.Service.DoesNotExist:
                        LOGGER.info("Site %s pushed new service %s", request.user.site, name)
                        service = models.Service(
                            name=name,
                            description=description,
                        )
                        service.save()
                        service.groups.add(group)
                        service.site.add(request.user.site)
                        service.handle_group_deployments()

        # TODO deactivate vanished services

        response = {
            'rabbitmq_config': RabbitMQInstanceSerializer(
                RabbitMQInstance.load(),
            ).data,
            'site': request.user.site.name,
        }
        return Response(response)


def response_view_error(err):
    return Response(
        data={'error': err},
        status=500,
    )


class ResponseView(views.APIView):
    authentication_classes = AUTHENTICATION_CLASSES

    def post(self, request):
        client_site = request.user.site
        output = request.data.get('output', {})
        state_id = request.data.get('id', None)
        _service = request.data.get('service', {})

        service = None
        service_query = client_site.services.filter(
            name=_service['name'],
        )
        #LOGGER.debug("[ResponseView]services: %s %s", service_query, len(service_query))
        if service_query.exists() and len(service_query) == 1:
            service = service_query.first()
        else:
            LOGGER.error(
                '[ResponseView] Unknown service %s from %s',
                _service['name'],
                request.user,
            )
            return response_view_error('unable to determine service')

        if state_id is None:
            err = 'no state id'
            LOGGER.error('Error parsing response from %s: %s', request.user, err)
            return response_view_error(err)

        # find the corresponding DeploymentStateItem for this response
        state_item = None
        query = client_site.state_items.filter(
            parent__id=int(state_id),
            site=client_site,
            service=service,
        )
        if query.exists():
            if len(query) == 1:
                state_item = query.first()
            else:
                LOGGER.error('[ResponseView] ambiguous DStateItem')
                return response_view_error('ambiguous DeploymentStateItem')
        else:
            LOGGER.error('[ResponseView] No matching DStateItem')
            return response_view_error('no matching DeploymentStateItem')

        if state_item is not None:
            err = state_item.client_response(output)
            if err is not None:
                LOGGER.error('[ResponseView] Error parsing response from %s: %s', request.user, err)
                return response_view_error(err)
            return Response({})

        LOGGER.info('[ResponseView] %s executed the obsolete state#%s', request.user, state_id)
        return response_view_error('obsolete state')