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 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 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 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 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 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 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 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 private_loopboxes(request):
try:
server = Server.objects.get(address=request.META['REMOTE_ADDR'])
j = [{'id': loopbox.pk, 'uid':loopbox.container.uid, 'filename': loopbox.filename, 'mountpoint': loopbox.mountpoint, 'ro': loopbox.ro } for loopbox in Loopbox.objects.filter(container__server=server)]
return spit_json(request, j)
except:
return HttpResponseForbidden('Forbidden\n')
def private_custom_services(request):
try:
server = Server.objects.get(address=request.META['REMOTE_ADDR'])
j = [{'customer':service.customer.pk, 'config': service.config, 'mtime': service.munix, 'id': service.pk } for service in server.customservice_set.all()]
return spit_json(request, j)
except:
return HttpResponseForbidden('Forbidden\n')
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 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')
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 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')
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 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 private_privileged_secret_uuids(request):
try:
privileged_client = PrivilegedClient.objects.get(address=request.META['REMOTE_ADDR'])
j = [{'uid':container.uid, 'mtime': container.munix, 'secret_uuid': container.secret_uuid, 'address': container.server.address } for container in Container.objects.all().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')
def private_custom_services(request):
try:
server = Server.objects.get(address=request.META['REMOTE_ADDR'])
j = [{'customer':service.customer.pk, 'config': service.config, 'mtime': service.munix, 'id': service.pk } for service in server.customservice_set.all()]
return spit_json(request, j)
except:
return HttpResponseForbidden('Forbidden\n')
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 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 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 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 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 private_loopboxes(request):
try:
server = Server.objects.get(address=request.META['REMOTE_ADDR'])
j = [{'id': loopbox.pk, 'uid':loopbox.container.uid, 'filename': loopbox.filename, 'mountpoint': loopbox.mountpoint, 'ro': loopbox.ro } for loopbox in Loopbox.objects.filter(container__server=server)]
return spit_json(request, j)
except:
return HttpResponseForbidden('Forbidden\n')
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 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 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 private_domains_rsa(request):
server = Server.objects.get(address=request.META['REMOTE_ADDR'])
server_customers = Customer.objects.filter(container__server=server)
j = []
for customer in server_customers:
domains = []
for domain in customer.domain_set.all():
domains.append({'name': domain.name, 'mtime': domain.munix})
j.append({'rsa': customer.rsa_pubkey, 'domains': domains })
return spit_json(request, j)
def news(request):
news_list = []
user = api_auth(request)
if user:
for n in News.objects.all()[0:10]:
news_list.append({"content": n.content, "date": int(time.mktime(n.ctime.timetuple()))})
else:
for n in News.objects.filter(public=True)[0:10]:
news_list.append({"content": n.content, "date": int(time.mktime(n.ctime.timetuple()))})
return spit_json(request, news_list)
def private_domains_rsa(request):
server = Server.objects.get(address=request.META['REMOTE_ADDR'])
server_customers = Customer.objects.filter(container__server=server)
j = []
for customer in server_customers:
domains = []
for domain in customer.domain_set.all():
domains.append({'name': domain.name, 'mtime': domain.munix})
j.append({'rsa': customer.rsa_pubkey, 'domains': domains })
return spit_json(request, j)
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 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 news(request):
news_list = []
user = api_auth(request)
if user:
for n in News.objects.all()[0:10]:
news_list.append({'content': n.content,
'date': int(time.mktime(n.ctime.timetuple()))})
else:
for n in News.objects.filter(public=True)[0:10]:
news_list.append({'content': n.content,
'date': int(time.mktime(n.ctime.timetuple()))})
return spit_json(request, news_list)
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 private_privileged_secret_uuids(request):
try:
privileged_client = PrivilegedClient.objects.get(
address=request.META['REMOTE_ADDR'])
j = [{
'uid': container.uid,
'mtime': container.munix,
'secret_uuid': container.secret_uuid,
'address': container.server.address
} for container in Container.objects.all().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')
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 private_portmappings(request):
try:
server = Server.objects.get(address=request.META['REMOTE_ADDR'])
unix = server.portmappings_munix
pmappings = []
for portmap in Portmap.objects.filter(container__server=server):
pmappings.append({
'proto': portmap.proto,
'public_ip': str(portmap.container.server.address),
'public_port': portmap.public_port,
'private_ip': str(portmap.container.ip),
'private_port': portmap.private_port,
})
if portmap.munix > unix:
unix = portmap.munix
j = {'unix': unix, 'mappings':pmappings}
return spit_json(request, j)
except:
return HttpResponseForbidden('Forbidden\n')
def private_server_file_metadata(request):
try:
server = Server.objects.get(address=request.META['REMOTE_ADDR'])
if request.method == 'POST':
response = check_body(request)
if response: return response
j = json.loads(request.read())
metadata = ServerFileMetadata.objects.get(filename=j['file'])
sm, created = ServerMetadata.objects.get_or_create(server=server, metadata=metadata)
sm.value = j['value']
sm.save()
response = HttpResponse('Created\n')
response.status_code = 201
return response
files = []
for _file in ServerFileMetadata.objects.all():
files.append(_file.filename)
return spit_json(request, files)
except:
import sys
print sys.exc_info()
return HttpResponseForbidden('Forbidden\n')
def distros(request):
j = [{'id': d.pk, 'name': d.name} for d in Distro.objects.all()]
return spit_json(request, j)
def alarms(request):
query = {}
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()
if 'vassal' in request.GET:
query['vassal'] = request.GET['vassal']
if 'class' in request.GET:
query['_class'] = request.GET['class']
if 'color' in request.GET:
query['color'] = request.GET['color']
if 'level' in request.GET:
query['level'] = int(request.GET['level'])
if 'line' in request.GET:
query['line'] = int(request.GET['line'])
if 'filename' in request.GET:
query['filename'] = request.GET['filename']
if 'func' in request.GET:
query['func'] = request.GET['func']
alarms = Alarm.objects.filter(**query)
a = []
if 'with_total' in request.GET:
response = {'total': alarms.count(), 'alarms': a}
else:
response = a
if 'range' in request.GET:
to = request.GET['range']
try:
if '-' in to:
_from, to = to.split('-')
else:
_from = 0
alarms = alarms[int(min(_from, to)):int(max(_from, to))]
except:
response = HttpResponse(json.dumps(
{'error': 'Requested Range Not Satisfiable'}),
content_type="application/json")
response.status_code = 416
return response
if _from > to:
alarms = alarms.reverse()
for alarm in alarms:
aa = {
'id': alarm.pk,
'container': alarm.container.uid,
'level': alarm.level,
'color': alarm.color,
'class': alarm._class,
'vassal': alarm.vassal,
'line': alarm.line,
'filename': alarm.filename,
'func': alarm.func,
'unix': int(alarm.unix.strftime('%s')),
'msg': alarm.msg
}
a.append(aa)
return spit_json(request, response)
def container(request, id):
customer = request.user.customer
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':
response = check_body(request)
if response:
return response
allowed_keys = (
'name',
'note',
'quota_threshold',
'jid',
'jid_secret',
'jid_destinations',
'nofollow',
'pushover_user',
'pushover_token',
'pushover_sound',
'alarm_freq',
)
j = json.loads(request.read())
if not j:
return HttpResponseForbidden(json.dumps({'error': 'Forbidden'}),
content_type="application/json")
for key in j:
if key in allowed_keys:
setattr(container, key, j[key])
if 'ssh_keys' in j:
container.ssh_keys_raw = '\n'.join(j['ssh_keys'])
container.ssh_keys_mtime = datetime.datetime.now()
if 'distro' in j:
container.distro = Distro.objects.get(pk=j['distro'])
if 'memory' in j:
if container.server.owner == customer:
container.memory = int(j['memory'])
if 'storage' in j:
if container.server.owner == customer:
container.storage = int(j['storage'])
if 'tags' in j:
new_tags = []
for tag in j['tags']:
try:
new_tags.append(
Tag.objects.get(customer=customer, name=tag))
except:
pass
container.tags = new_tags
# linking and unlinking requires reboot
if 'link' in j:
try:
link = ContainerLink()
link.container = container
link.to = Container.objects.get(pk=(int(j['link']) -
UWSGI_IT_BASE_UID))
link.full_clean()
link.save()
container.last_reboot = datetime.datetime.now()
except:
response = HttpResponse(json.dumps({'error': 'Conflict'}),
content_type="application/json")
response.status_code = 409
return response
if 'unlink' in j:
try:
link = container.containerlink_set.get(to=(int(j['unlink']) -
UWSGI_IT_BASE_UID))
link.delete()
container.last_reboot = datetime.datetime.now()
except:
response = HttpResponse(json.dumps({'error': 'Conflict'}),
content_type="application/json")
response.status_code = 409
return response
if 'reboot' in j:
container.last_reboot = datetime.datetime.now()
container.full_clean()
container.save()
c = {
'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,
'jid': container.jid,
'jid_destinations': container.jid_destinations,
'pushover_user': container.pushover_user,
'pushover_token': container.pushover_token,
'pushover_sound': container.pushover_sound,
'alarm_freq': container.alarm_freq,
'quota_threshold': container.quota_threshold,
'nofollow': container.nofollow,
'note': container.note,
'linked_to': container.linked_to,
'ssh_keys': container.ssh_keys,
'tags': [t.name for t in container.tags.all()],
'legion_address':
[l.address for l in container.server.legion_set.all()]
}
if container.distro:
c['distro'] = container.distro.pk
c['distro_name'] = container.distro.name
return spit_json(request, c)
