app.py

"""
App and release views.
"""
import re
from django.conf import settings
from django.db import transaction
from django.db.models import Q
from rest_framework import filters, status
from rest_framework.decorators import action
from rest_framework.exceptions import PermissionDenied, ValidationError
from rest_framework.response import Response
from django.shortcuts import get_object_or_404

from api import models, serializers
from api.exceptions import AlreadyExists, DryccException
from api.viewsets import BaseAppViewSet


class AppFilterViewSet(BaseAppViewSet):
    """A viewset for objects which are attached to an application."""

    def get_app(self):
        app = get_object_or_404(models.app.App, id=self.kwargs['id'])
        self.check_object_permissions(self.request, app)
        return app

    def get_queryset(self, **kwargs):
        app = self.get_app()
        return self.model.objects.filter(app=app)

    def get_object(self, **kwargs):
        return self.get_queryset(**kwargs).latest('created')

    def create(self, request, **kwargs):
        request.data['app'] = self.get_app()
        return super().create(request, **kwargs)


class ReleasableViewSet(AppFilterViewSet):
    """A viewset for application resources which affect the release cycle."""

    def get_object(self):
        """Retrieve the object based on the latest release's value"""
        version = self.request.query_params.get('version', '').lower().strip('v')
        if re.search("^[0-9]+$", version):
            release = get_object_or_404(
                models.release.Release, app=self.get_app(), version=int(version))
        else:
            release = models.release.Release.latest(self.get_app())
        return getattr(release, self.model.__name__.lower())


class AppViewSet(BaseAppViewSet):
    """A viewset for interacting with App objects."""
    model = models.app.App
    lookup_value_regex = settings.APP_URL_REGEX
    filter_backends = [filters.SearchFilter]
    search_fields = ['^id', ]
    serializer_class = serializers.AppSerializer

    def list(self, request, *args, **kwargs):
        queryset = self.filter_queryset(self.get_queryset())
        workspace = request.query_params.get('workspace')
        if workspace:
            workspace_obj = get_object_or_404(models.workspace.Workspace, id=workspace)
            if not workspace_obj.has_member(request.user):
                raise PermissionDenied(f"You are not a member of workspace '{workspace_obj.id}'")
            queryset = queryset.filter(workspace=workspace_obj)
        page = self.paginate_queryset(queryset)
        if page is not None:
            serializer = self.get_serializer(page, many=True)
            return self.get_paginated_response(serializer.data)
        serializer = self.get_serializer(queryset, many=True)
        return Response(serializer.data)

    @action(detail=True, methods=['post'])
    def run(self, request, **kwargs):
        app = self.get_object()
        ptype = request.data.get('ptype', 'run')
        command = request.data.get('command', '').split()
        timeout = int(request.data.get('timeout', 3600))
        expires = int(request.data.get('expires', 3600))
        if expires == 0 or expires > settings.KUBERNETES_JOB_MAX_TTL_SECONDS_AFTER_FINISHED:
            expires = settings.KUBERNETES_JOB_MAX_TTL_SECONDS_AFTER_FINISHED
        if not command:
            raise DryccException('command is a required field, or it can be defined in Procfile')
        release = models.release.Release.latest(app)
        if release is None or release.build is None:
            raise DryccException('no build available, please deploy a release')
        volumes = request.data.get('volumes', None)
        if volumes:
            volumes = serializers.VolumeSerializer().validate_path(volumes)
        app.run(self.request.user, release.get_deploy_image(ptype),
                command=release.get_deploy_command(ptype), args=command, volumes=volumes,
                timeout=timeout, expires=expires)
        return Response(status=status.HTTP_204_NO_CONTENT)

    def perform_create(self, serializer):
        workspace = serializer.validated_data['workspace']
        self.check_object_permissions(self.request, workspace)
        serializer.save()

    def update(self, request, *args, **kwargs):
        app = self.get_object()
        if not app.workspace.has_member(request.user, role='admin'):
            raise PermissionDenied("you must be an admin of the current workspace")
        workspace = request.data.get('workspace', '')
        if not workspace:
            raise ValidationError("workspace is required")
        app.workspace = get_object_or_404(models.workspace.Workspace, id=workspace)
        app.save()
        return Response(status=status.HTTP_204_NO_CONTENT)

    @transaction.atomic
    def destroy(self, request, *args, **kwargs):
        return super().destroy(request, *args, **kwargs)


class BuildViewSet(ReleasableViewSet):
    """A viewset for interacting with Build objects."""
    model = models.build.Build
    serializer_class = serializers.BuildSerializer

    def perform_create(self, serializer):
        build = serializer.save()
        for ptype in build.ptypes:
            image = build.get_image(ptype)
            is_loopback = re.compile(r'^(localhost|127\.0\.0\.1)(:\d+)?/').match
            if is_loopback(image):
                raise DryccException("image must not use the loopback address")
        build.create_release(self.request.user)


class ConfigViewSet(ReleasableViewSet):
    """A viewset for interacting with Config objects."""
    model = models.config.Config
    serializer_class = serializers.ConfigSerializer

    def create(self, request, **kwargs):
        if self.request.query_params.get('merge', 'true').lower() == 'true':
            return super().create(request, **kwargs)
        values = self.get_serializer().validate_values(request.data.get('values'))
        config = self.model(app=self.get_app(), values=values)
        old_config = config.previous()
        if old_config and old_config.values:
            replace_ptypes = {v['ptype'] for v in config.values if 'ptype' in v}
            replace_groups = {v['group'] for v in config.values if 'group' in v}
            config.merge_field("values", old_config, replace_ptypes, replace_groups)
        config.save(ignore_update_fields=["values"])
        self.post_save(config)
        data = self.get_serializer(config).data
        headers = self.get_success_headers(data)
        return Response(data, status=status.HTTP_201_CREATED, headers=headers)

    def perform_create(self, serializer):
        config = serializer.save()
        self.post_save(config)

    def destroy(self, request, **kwargs):
        values_refs = self.get_serializer().validate_values_refs(
            request.data.get('values_refs', {}))
        if not values_refs or not values_refs.values():
            raise DryccException("ptype or groups is required")

        config = self.model(app=self.get_app(), values_refs={})
        previous = config.previous()
        old_values_refs = previous.values_refs.copy() if previous else {}
        for ptype, old_groups in old_values_refs.items():
            groups_to_delete = values_refs.get(ptype, [])
            for group in old_groups:
                if group not in groups_to_delete:
                    if ptype not in config.values_refs:
                        config.values_refs[ptype] = [group]
                    elif group not in config.values_refs[ptype]:
                        config.values_refs[ptype].append(group)
        config.save(ignore_update_fields=["values_refs"])
        self.post_save(config)
        return Response(status=status.HTTP_200_OK)

    def post_save(self, config):
        latest_release = models.release.Release.latest(self.get_app())
        try:
            build = latest_release.build.merge(config) if latest_release.build else None
            release = latest_release.new(self.request.user, config=config, build=build)
            if release.build and config.app.appsettings_set.latest().autodeploy:
                release.deploy(release.ptypes, False)
        except BaseException as e:
            config.delete()
            if isinstance(e, AlreadyExists):
                raise
            raise DryccException(str(e)) from e


class ReleaseViewSet(AppFilterViewSet):
    """A viewset for interacting with Release objects."""
    model = models.release.Release
    serializer_class = serializers.ReleaseSerializer

    def get_object(self, **kwargs):
        """Get release by version always"""
        qs = self.get_queryset(**kwargs)
        return get_object_or_404(qs, version=self.kwargs['version'])

    def get_queryset(self, **kwargs):
        ptypes = self.request.query_params.get('ptypes', '').strip()
        queryset = super().get_queryset(**kwargs)
        if ptypes:
            queryset = queryset.filter(Q(
                deployed_ptypes__contains=[
                    ptype.lower() for ptype in re.split(r"\W+", ptypes)]))
        return queryset

    def deploy(self, request, **kwargs):
        """Deploy the latest release"""
        latest_release = self.get_app().release_set.latest()

        force_deploy = request.data.get("force", False)
        ptypes = set(
            [ptype for ptype in request.data.get("ptypes", "").split(",") if ptype])
        if not ptypes:
            ptypes = latest_release.ptypes
        else:
            invalid_ptypes = ptypes.difference(
                latest_release.ptypes + [d["name"] for d in self.get_app().list_deployments()])
            if len(invalid_ptypes) != 0:
                raise DryccException(f"process type {','.join(invalid_ptypes)} is not exists")
        latest_release.deploy(ptypes, force_deploy)
        return Response(status=status.HTTP_204_NO_CONTENT)

    def rollback(self, request, **kwargs):
        """
        Create a new release as a copy of the state of the compiled slug and config vars of a
        previous release.
        """
        latest_release = models.release.Release.latest(self.get_app())
        ptypes = set(
            [ptype for ptype in request.data.get("ptypes", "").split(",") if ptype])
        ptypes = latest_release.app.check_ptypes(ptypes)
        new_release = latest_release.rollback(
            request.user, ptypes, request.data.get('version', None))
        response = {'version': new_release.version}
        return Response(response, status=status.HTTP_201_CREATED)