Python utils.check_body函数代码示例

def domains(request):
    customer = request.user.customer

    if request.method == 'POST':
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        if Domain.objects.filter(name=j['name']):
            response = HttpResponse(json.dumps({'error': 'Conflict'}),
                                    content_type="application/json")
            response.status_code = 409
            return response
        if dns_check(j['name'], customer.uuid):
            try:
                customer.domain_set.create(name=j['name'])
                response = HttpResponse(json.dumps({'message': 'Created'}),
                                        content_type="application/json")
                response.status_code = 201
            except:
                response = HttpResponse(json.dumps({'error': 'Conflict'}),
                                        content_type="application/json")
                response.status_code = 409
            return response
        else:
            return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}),
                                         content_type="application/json")

    elif request.method == 'DELETE':
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        try:
            customer.domain_set.get(name=j['name']).delete()
        except Domain.DoesNotExist:
            return HttpResponseNotFound(json.dumps({'error': 'Not found'}),
                                        content_type="application/json")
        return HttpResponse(json.dumps({'message': 'Ok'}),
                            content_type="application/json")

    elif request.method == 'GET':
        if 'tags' in request.GET:
            j = [{'id': d.pk, 'name': d.name, 'uuid': d.uuid,
                  'tags': [t.name for t in d.tags.all()]} for d in
                 customer.domain_set.filter(
                     tags__name__in=request.GET['tags'].split(','))]
        else:
            j = [{'id': d.pk, 'name': d.name, 'uuid': d.uuid,
                  'tags': [t.name for t in d.tags.all()]} for d in
                 customer.domain_set.all()]
        return spit_json(request, j)

    response = HttpResponse(json.dumps({'error': 'Method not allowed'}),
                            content_type="application/json")
    response.status_code = 405
    return response

def portmappings(request, ip):
    customer = request.user.customer
    try:
        server = Server.objects.get(address=ip, owner=customer)
    except:
        return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
    if request.method == "POST":
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        if not j:
            return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
        pm = Portmap()
        try:
            pm.proto = j["proto"]
            pm.public_port = int(j["public_port"])
            pm.private_port = int(j["private_port"])
            pm.container = server.container_set.get(pk=(int(j["container"]) - UWSGI_IT_BASE_UID), customer=customer)
            pm.full_clean()
            pm.save()
        except:
            import sys

            print sys.exc_info()
            return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
        response = HttpResponse(json.dumps({"message": "Created"}), content_type="application/json")
        response.status_code = 201
        return response
    elif request.method == "DELETE":
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        if not j:
            return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
        try:
            pm = Portmap.objects.get(pk=j["id"], container__server=server)
            pm.delete()
        except:
            return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
        return HttpResponse(json.dumps({"message": "Ok"}), content_type="application/json")
    mappings = []
    for portmap in Portmap.objects.filter(container__server=server):
        mappings.append(
            {
                "id": portmap.pk,
                "proto": portmap.proto,
                "public_port": portmap.public_port,
                "container": portmap.container.uid,
                "container_ip": str(portmap.container.ip),
                "private_port": portmap.private_port,
            }
        )
    return spit_json(request, mappings)

def domains(request):
    customer = request.user.customer

    if request.method == "POST":
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        if Domain.objects.filter(name=j["name"]):
            response = HttpResponse(json.dumps({"error": "Conflict"}), content_type="application/json")
            response.status_code = 409
            return response
        if dns_check(j["name"], customer.uuid):
            try:
                customer.domain_set.create(name=j["name"])
                response = HttpResponse(json.dumps({"message": "Created"}), content_type="application/json")
                response.status_code = 201
            except:
                response = HttpResponse(json.dumps({"error": "Conflict"}), content_type="application/json")
                response.status_code = 409
            return response
        else:
            return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")

    elif request.method == "DELETE":
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        try:
            customer.domain_set.get(name=j["name"]).delete()
        except Domain.DoesNotExist:
            return HttpResponseNotFound(json.dumps({"error": "Not found"}), content_type="application/json")
        return HttpResponse(json.dumps({"message": "Ok"}), content_type="application/json")

    elif request.method == "GET":
        if "tags" in request.GET:
            j = [
                {"id": d.pk, "name": d.name, "uuid": d.uuid, "tags": [t.name for t in d.tags.all()]}
                for d in customer.domain_set.filter(tags__name__in=request.GET["tags"].split(","))
            ]
        else:
            j = [
                {"id": d.pk, "name": d.name, "uuid": d.uuid, "tags": [t.name for t in d.tags.all()]}
                for d in customer.domain_set.all()
            ]
        return spit_json(request, j)

    response = HttpResponse(json.dumps({"error": "Method not allowed"}), content_type="application/json")
    response.status_code = 405
    return response

def portmappings(request, ip):
    customer = request.user.customer
    try:
        server = Server.objects.get(address=ip,owner=customer)
    except:
        return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
    if request.method == 'POST':
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        if not j:
            return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        pm = Portmap()
        try:
            pm.proto = j['proto']
            pm.public_port = int(j['public_port'])
            pm.private_port = int(j['private_port'])
            pm.container = server.container_set.get(pk=(int(j['container']) - UWSGI_IT_BASE_UID), customer=customer)
            pm.full_clean()
            pm.save()
        except:
            import sys
            print sys.exc_info()
            return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        response = HttpResponse(json.dumps({'message': 'Created'}), content_type="application/json")
        response.status_code = 201
        return response
    elif request.method == 'DELETE':
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        if not j:
            return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        try:
            pm = Portmap.objects.get(pk=j['id'], container__server=server)
            pm.delete()
        except:
            return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        return HttpResponse(json.dumps({'message': 'Ok'}), content_type="application/json")
    mappings = []
    for portmap in Portmap.objects.filter(container__server=server):
        mappings.append({'id': portmap.pk,
                         'proto': portmap.proto,
                         'public_port': portmap.public_port,
                         'container': portmap.container.uid,
                         'container_ip': str(portmap.container.ip),
                         'private_port': portmap.private_port,
                       })
    return spit_json(request, mappings)

def custom_distro(request, id):
    customer = request.user.customer
    try:
        distro = CustomDistro.objects.get(pk=id, container__customer=customer)
    except:
        return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}),
                                     content_type="application/json")
    if request.method == 'DELETE':
        distro.delete()
        return HttpResponse(json.dumps({'message': 'Ok'}),
                            content_type="application/json")
    if request.method == 'POST':
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        allowd_fields = ('name', 'path', 'note')
        for field in allowed_fields:
            if field in j:
                setattr(distro, field, j[field])
        distro.full_clean()
        distro.save()
    d = {
        'id': distro.pk,
        'container': distro.container.uid,
        'name': distro.name,
        'path': distro.path,
        'note': distro.note,
        'uuid': distro.uuid,
    }
    return spit_json(request, d)

def tag(request, id):
    customer = request.user.customer
    try:
        t = Tag.objects.get(customer=customer, pk=id)
    except:
        return HttpResponseNotFound(json.dumps({'error': 'Not found'}), content_type="application/json")

    allowed_keys = ('name', 'note')
    if request.method == 'POST':
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        for key in allowed_keys:
            if key in j:
                setattr(t, key, j[key])
        try:
            t.save()
            j = {'id': t.pk, 'name': t.name, 'note': t.note}
            return spit_json(request, j)
        except:
            response = HttpResponse(json.dumps({'error': 'Conflict'}), content_type="application/json")
            response.status_code = 409
        return response
    elif request.method == 'GET':
        j = {'id': t.pk, 'name': t.name, 'note': t.note}
        return spit_json(request, j)
    elif request.method == 'DELETE':
        t.delete()
        return HttpResponse(json.dumps({'message': 'Ok'}), content_type="application/json")
    allowed_keys = ('name', 'note')
    response = HttpResponse(json.dumps({'error': 'Method not allowed'}), content_type="application/json")
    response.status_code = 405
    return response

def me(request):
    customer = request.user.customer
    if request.method == "POST":
        response = check_body(request)
        if response:
            return response
        allowed_keys = ("vat", "company")
        j = json.loads(request.read())
        for key in j:
            if key in allowed_keys:
                setattr(customer, key, j[key])
        if "password" in j:
            customer.user.set_password(j["password"])
            customer.user.save()
        if "email" in j:
            customer.user.email = j["email"]
            customer.user.save()
        customer.save()
    c = {
        "email": customer.user.email,
        "vat": customer.vat,
        "company": customer.company,
        "uuid": customer.uuid,
        "containers": [cc.uid for cc in customer.container_set.all()],
        "servers": [s.address for s in customer.server_set.all()],
    }
    return spit_json(request, c)

def tags(request):
    customer = request.user.customer
    allowed_keys = ("name", "note")
    if request.method == "POST":
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        tag = Tag(customer=customer)
        for key in allowed_keys:
            if key in j:
                setattr(tag, key, j[key])
        try:
            tag.save()
            j = {"id": tag.pk, "name": tag.name, "note": tag.note}
            response = spit_json(request, j)
            response.status_code = 201
            response.reason_phrase = "Created"
        except:
            response = HttpResponse(json.dumps({"error": "Conflict"}), content_type="application/json")
            response.status_code = 409
        return response

    elif request.method == "GET":
        j = [{"id": t.pk, "name": t.name} for t in Tag.objects.filter(customer=customer)]
        return spit_json(request, j)
    response = HttpResponse(json.dumps({"error": "Method not allowed"}), content_type="application/json")
    response.status_code = 405
    return response

def custom_distro(request, id):
    customer = request.user.customer
    try:
        distro = CustomDistro.objects.get(pk=id, container__customer=customer)
    except:
        return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
    if request.method == "DELETE":
        distro.delete()
        return HttpResponse(json.dumps({"message": "Ok"}), content_type="application/json")
    if request.method == "POST":
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        allowd_fields = ("name", "path", "note")
        for field in allowed_fields:
            if field in j:
                setattr(distro, field, j[field])
        distro.full_clean()
        distro.save()
    d = {
        "id": distro.pk,
        "container": distro.container.uid,
        "name": distro.name,
        "path": distro.path,
        "note": distro.note,
        "uuid": distro.uuid,
    }
    return spit_json(request, d)

def custom_distros(request, id=None):
    customer = request.user.customer
    if not id:
        j = [{'id': d.pk, 'name': d.name, 'container': d.container.uid} for d in CustomDistro.objects.filter(container__customer=customer)]
        return spit_json(request, j)
    try:
        container = customer.container_set.get(pk=(int(id) - UWSGI_IT_BASE_UID))
    except:
        return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
    if request.method == 'POST':
        if not container.custom_distros_storage:
            return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        distro = CustomDistro(container=container) 
        allowed_fields = ('name', 'path', 'note')
        for field in allowed_fields:
            if field in j:
                setattr(distro, field, j[field])
        try:
            distro.full_clean()
            distro.save()
        except:
            return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        response = HttpResponse(json.dumps({'message': 'Created'}), content_type="application/json")
        response.status_code = 201
        return response
    j = [{'id': d.pk, 'name': d.name} for d in CustomDistro.objects.filter(container__server=container.server,container__customer=customer).exclude(container=container)]
    return spit_json(request, j)

def loopbox(request, id):
    customer = request.user.customer
    try:
        loopbox = Loopbox.objects.get(pk=id, container__in=customer.container_set.all())
    except:
        return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
    if request.method == 'POST':
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        if not j:
            return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        if 'tags' in j:
            new_tags = []
            for tag in j['tags']:
                try:
                    new_tags.append(Tag.objects.get(customer=customer, name=tag))
                except:
                    pass
            loopbox.tags = new_tags
        loopbox.save()
    elif request.method == 'DELETE':
        loopbox.delete()
        return HttpResponse(json.dumps({'message': 'Ok'}), content_type="application/json")
    l = {
        'id': loopbox.pk,
        'container': loopbox.container.uid,
        'filename': loopbox.filename,
        'mountpoint': loopbox.mountpoint,
        'ro': loopbox.ro,
        'tags': [t.name for t in loopbox.tags.all()]
    }
    return spit_json(request, l)

def loopbox(request, id):
    customer = request.user.customer
    try:
        loopbox = Loopbox.objects.get(pk=id, container__in=customer.container_set.all())
    except:
        return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
    if request.method == "POST":
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        if not j:
            return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
        if "tags" in j:
            new_tags = []
            for tag in j["tags"]:
                try:
                    new_tags.append(Tag.objects.get(customer=customer, name=tag))
                except:
                    pass
            loopbox.tags = new_tags
        loopbox.save()
    elif request.method == "DELETE":
        loopbox.delete()
        return HttpResponse(json.dumps({"message": "Ok"}), content_type="application/json")
    l = {
        "id": loopbox.pk,
        "container": loopbox.container.uid,
        "filename": loopbox.filename,
        "mountpoint": loopbox.mountpoint,
        "ro": loopbox.ro,
        "tags": [t.name for t in loopbox.tags.all()],
    }
    return spit_json(request, l)

def containers(request):
    if request.method == 'POST':
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        needed_keys = ('server', 'name', 'memory', 'storage')
        for k in needed_keys:
            if not k in j.keys():
                return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        try:
            server = Server.objects.get(address=j['server'])
            if server.owner != request.user.customer:
                return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        except:
            return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        try:
            container = Container(customer=request.user.customer, server=server)
            container.name = j['name']
            container.memory = int(j['memory'])
            container.storage = int(j['storage'])
            container.save()
            response = HttpResponse(json.dumps({'message': 'Created'}), content_type="application/json")
            response.status_code = 201
            return response
        except:
            response = HttpResponse(json.dumps({'error': 'Conflict'}), content_type="application/json")
            response.status_code = 409
            return response
    elif (request.method == 'GET' and
         'tags' in request.GET):
            containers = request.user.customer.container_set.filter(tags__name__in=request.GET['tags'].split(','))
    else:
        containers = request.user.customer.container_set.all()

    c = []
    for container in containers:
        cc = {
            'uid': container.uid,
            'name': container.name,
            'hostname': container.hostname,
            'ip': str(container.ip),
            'memory': container.memory,
            'storage': container.storage,
            'uuid': container.uuid,
            'distro': None,
            'distro_name': None,
            'server': container.server.name,
            'server_address': container.server.address,
            'tags': [t.name for t in container.tags.all()]
        }
        if container.distro:
            cc['distro'] = container.distro.pk
            cc['distro_name'] = container.distro.name
        c.append(cc)

    return spit_json(request, c)

def loopboxes(request):
    if request.method == "POST":
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        needed_keys = ("container", "filename", "mountpoint")
        for k in needed_keys:
            if not k in j.keys():
                return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
        try:
            container = request.user.customer.container_set.get(pk=(int(j["container"]) - UWSGI_IT_BASE_UID))
        except:
            return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
        try:
            loopbox = Loopbox(container=container)
            loopbox.filename = j["filename"]
            loopbox.mountpoint = j["mountpoint"]
            if "ro" in j:
                loopbox.ro = j["ro"]
            loopbox.save()
            response = HttpResponse(json.dumps({"message": "Created"}), content_type="application/json")
            response.status_code = 201
            return response
        except:
            response = HttpResponse(json.dumps({"error": "Conflict"}), content_type="application/json")
            response.status_code = 409
            return response
    elif request.method == "GET":
        query = {}
        if "tags" in request.GET:
            query["tags__name__in"] = request.GET["tags"].split(",")
        if "container" in request.GET:
            try:
                query["container"] = request.user.customer.container_set.get(
                    pk=(int(request.GET["container"]) - UWSGI_IT_BASE_UID)
                )
            except:
                return HttpResponseForbidden(json.dumps({"error": "Forbidden"}), content_type="application/json")
        else:
            query["container__in"] = request.user.customer.container_set.all()
        loopboxes = Loopbox.objects.filter(**query)
    else:
        loopboxes = Loopbox.objects.filter(container__in=request.user.customer.container_set.all())

    l = []
    for loopbox in loopboxes:
        ll = {
            "id": loopbox.pk,
            "container": loopbox.container.uid,
            "filename": loopbox.filename,
            "mountpoint": loopbox.mountpoint,
            "ro": loopbox.ro,
            "tags": [t.name for t in loopbox.tags.all()],
        }
        l.append(ll)
    return spit_json(request, l)

def loopboxes(request):
    if request.method == 'POST':
        response = check_body(request)
        if response:
            return response
        j = json.loads(request.read())
        needed_keys = ('container', 'filename', 'mountpoint')
        for k in needed_keys:
            if not k in j.keys():
                return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        try:
            container = request.user.customer.container_set.get(pk=(int(j['container']) - UWSGI_IT_BASE_UID))
        except:
            return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        try:
            loopbox = Loopbox(container=container)
            loopbox.filename = j['filename']
            loopbox.mountpoint = j['mountpoint']
            if 'ro' in j:
                loopbox.ro = j['ro']
            loopbox.save()
            response = HttpResponse(json.dumps({'message': 'Created'}), content_type="application/json")
            response.status_code = 201
            return response
        except:
            response = HttpResponse(json.dumps({'error': 'Conflict'}), content_type="application/json")
            response.status_code = 409
            return response
    elif request.method == 'GET':
        query = {}
        if 'tags' in request.GET:
            query['tags__name__in'] = request.GET['tags'].split(',')
        if 'container' in request.GET:
            try:
                query['container'] = request.user.customer.container_set.get(pk=(int(request.GET['container']) - UWSGI_IT_BASE_UID))
            except:
                return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}), content_type="application/json")
        else:
            query['container__in'] = request.user.customer.container_set.all()
        loopboxes = Loopbox.objects.filter(**query)
    else:
        loopboxes = Loopbox.objects.filter(container__in=request.user.customer.container_set.all())

    l = []
    for loopbox in loopboxes:
        ll = {
            'id': loopbox.pk,
            'container': loopbox.container.uid,
            'filename': loopbox.filename,
            'mountpoint': loopbox.mountpoint,
            'ro': loopbox.ro,
            'tags': [t.name for t in loopbox.tags.all()]
        }
        l.append(ll)
    return spit_json(request, l)