Python utils.spit_json函数代码示例

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 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 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 domain(request, id):
    customer = request.user.customer
    try:
        domain = customer.domain_set.get(pk=id)
    except:
        return HttpResponseNotFound(json.dumps({"error": "Not found"}), content_type="application/json")
    allowed_keys = ("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(domain, key, j[key])
        if "tags" in j:
            new_tags = []
            for tag in j["tags"]:
                try:
                    new_tags.append(Tag.objects.get(customer=customer, name=tag))
                except:
                    pass
            domain.tags = new_tags
        try:
            domain.save()
            j = {
                "id": domain.pk,
                "name": domain.name,
                "uuid": domain.uuid,
                "tags": [t.name for t in domain.tags.all()],
                "note": domain.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 == "DELETE":
        domain.delete()
        return HttpResponse(json.dumps({"message": "Ok"}), content_type="application/json")

    elif request.method == "GET":
        j = {
            "id": domain.pk,
            "name": domain.name,
            "uuid": domain.uuid,
            "tags": [t.name for t in domain.tags.all()],
            "note": domain.note,
        }
        return spit_json(request, j)

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

def domain(request, id):
    customer = request.user.customer
    try:
        domain = customer.domain_set.get(pk=id)
    except:
        return HttpResponseNotFound(json.dumps({'error': 'Not found'}),
                                    content_type="application/json")
    allowed_keys = ('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(domain, key, j[key])
        if 'tags' in j:
            new_tags = []
            for tag in j['tags']:
                try:
                    new_tags.append(
                        Tag.objects.get(customer=customer, name=tag))
                except:
                    pass
            domain.tags = new_tags
        try:
            domain.save()
            j = {'id': domain.pk, 'name': domain.name, 'uuid': domain.uuid,
                 'tags': [t.name for t in domain.tags.all()],
                 'note': domain.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 == 'DELETE':
        domain.delete()
        return HttpResponse(json.dumps({'message': 'Ok'}),
                            content_type="application/json")

    elif request.method == 'GET':
        j = {'id': domain.pk, 'name': domain.name, 'uuid': domain.uuid,
             'tags': [t.name for t in domain.tags.all()],
             'note': domain.note}
        return spit_json(request, j)

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

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 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 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 alarm(request, id):
    customer = request.user.customer
    try:
        alarm = Alarm.objects.get(pk=id,
                                  container__in=customer.container_set.all())
    except:
        return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}),
                                     content_type="application/json")
    if request.method == 'DELETE':
        alarm.delete()
        return HttpResponse(json.dumps({'message': 'Ok'}),
                            content_type="application/json")
    a = {
        'id': alarm.pk,
        'container': alarm.container.uid,
        'level': alarm.level,
        'color': alarm.color,
        'class': alarm._class,
        'line': alarm.line,
        'filename': alarm.filename,
        'func': alarm.func,
        'vassal': alarm.vassal,
        'unix': int(alarm.unix.strftime('%s')),
        'msg': alarm.msg
    }
    return spit_json(request, a)

def domains_in_container(request, id):
    if request.method == 'GET':
        customer = request.user.customer
        try:
            container_obj = customer.container_set.get(pk=(int(id) - UWSGI_IT_BASE_UID))
        except:
            return HttpResponseNotFound(json.dumps({'error': 'Not found'}),
                                        content_type="application/json")

        today = datetime.datetime.today()
        domain_list = [{'id': d.pk, 'uuid': d.uuid, 'name': d.name} for d in Domain.objects.filter(
            pk__in=HitsDomainMetric.objects.values_list(
                'domain', flat=True).filter(
                container=container_obj,
                year=today.year,
                month=today.month,
                day=today.day
            ).order_by('-year', '-month', '-day')
        )]

        return spit_json(request, domain_list)

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

def containers_per_domain(request, id):
    if request.method == 'GET':
        customer = request.user.customer
        try:
            domain = customer.domain_set.get(pk=id)
        except:
            return HttpResponseNotFound(json.dumps({'error': 'Not found'}),
                                        content_type="application/json")

        today = datetime.datetime.today()
        container_list = [{'id': c.pk, 'uuid': c.uuid, 'name': c.name, 'uid': c.uid} for c in Container.objects.filter(
            pk__in=HitsDomainMetric.objects.values_list(
                'container', flat=True).filter(
                domain=domain,
                year=today.year,
                month=today.month,
                day=today.day
            ).order_by('-year', '-month', '-day')
        )]
        return spit_json(request, container_list)

    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 metrics_container_do(request, container, qs, prefix):
    """
    you can ask metrics for a single day of the year (288 metrics is the worst/general case)
    if the day is today, the response is cached for 5 minutes, otherwise it is cached indefinitely
    """
    today = datetime.datetime.today()
    year = today.year
    month = today.month
    day = today.day
    if 'year' in request.GET:year = int(request.GET['year'])
    if 'month' in request.GET: month = int(request.GET['month'])
    if 'day' in request.GET: day = int(request.GET['day'])
    expires = 86400
    if day != today.day or month != today.month or year != today.year: expires = 300
    try:
        # this will trigger the db query
        if not UWSGI_IT_METRICS_CACHE: raise
        cache = get_cache(UWSGI_IT_METRICS_CACHE)
        j = cache.get("%s_%d_%d_%d_%d" % (prefix, container.uid, year, month, day))
        if not j:
            j = qs.get(year=year,month=month,day=day).json
            cache.set("%s_%d_%d_%d_%d" % (prefix, container.uid, year, month, day ), j, expires)
    except: 
        import sys
        print sys.exc_info()
        try:
            j = qs.get(year=year,month=month,day=day).json
        except:
            j = "[]"
    return spit_json(request, j, expires, True)

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 private_containers(request):
    try:
        server = Server.objects.get(address=request.META['REMOTE_ADDR'])
        j = [{'uid':container.uid, 'mtime': container.munix, 'ssh_keys_mtime': container.ssh_keys_munix } for container in server.container_set.exclude(distro__isnull=True).exclude(ssh_keys_raw__exact='').exclude(ssh_keys_raw__isnull=True)]
        return spit_json(request, j)
    except:
        return HttpResponseForbidden('Forbidden\n')