def get_object(request,
model,
attrs,
where=None,
exists_ok=False,
noexists_fail=False,
sr=(),
pr=(),
extra=None,
annotate=None,
create_attrs=None,
data=None):
"""
Get or create object with attrs looked up by where.
Return error response when needed.
"""
obj = None
try:
qs = model.objects
if sr:
qs = qs.select_related(*sr)
if pr:
qs = qs.prefetch_related(*pr)
if annotate:
qs = qs.annotate(**annotate)
if extra:
qs = qs.extra(**extra)
if where:
qs = qs.filter(where)
obj = qs.get(**attrs)
except model.DoesNotExist:
if request.method in ('GET', 'PUT', 'DELETE') or noexists_fail:
raise ObjectNotFound(model=model)
elif request.method == 'POST':
if create_attrs:
new_obj_attrs = create_attrs
else:
new_obj_attrs = {
key: val
for key, val in iteritems(attrs) if '__' not in key
}
obj = model(**new_obj_attrs)
else:
if request.method == 'POST' and not exists_ok:
raise ObjectAlreadyExists(model=model)
return obj
def post(self):
dc, img = self.request.dc, self.img
if img.dc.filter(id=dc.id).exists():
raise ObjectAlreadyExists(model=Image)
ser = self.serializer(self.request, img)
img.dc.add(dc)
res = SuccessTaskResponse(self.request, ser.data, obj=img, status=status.HTTP_201_CREATED,
detail_dict=ser.detail_dict(), msg=LOG_IMAGE_ATTACH)
self._remove_dc_binding(res)
return res
def post(self):
dd = {}
if 'note' in self.data:
dd['note'] = note = self.data['note']
else:
note = ''
if 'usage' in self.data:
dd['usage'] = usage = self.data['usage']
else:
usage = IPAddress.VM
if self.many:
ips = self.ips
if not ips:
raise InvalidInput('Invalid ips')
if self.ip.exists(): # SELECT count(*) from IPAddress
raise ObjectAlreadyExists(model=IPAddress)
msg = LOG_IPS_CREATE
data = [{'ip': ip, 'usage': usage, 'note': note} for ip in ips]
dd['ips'] = '%s-%s' % (ips[0], ips[-1])
else:
msg = LOG_IP_CREATE
data = dd
data['ip'] = self.ip.ip
ser = NetworkIPSerializer(self.net, data=data, many=self.many)
if not ser.is_valid():
return FailureTaskResponse(self.request,
ser.errors,
dc_bound=False)
if self.many:
IPAddress.objects.bulk_create(ser.object) # INSERT into IPAddress
else:
ser.object.save() # INSERT into IPAddress
return SuccessTaskResponse(self.request,
ser.data,
status=HTTP_201_CREATED,
obj=self.net,
msg=msg,
detail_dict=dd,
dc_bound=False)
def post(self):
ns, dc = self.ns, self.request.dc
if ns.dc.filter(id=dc.id).exists():
raise ObjectAlreadyExists(model=NodeStorage)
ser = self.serializer(self.request, ns)
ns.dc.add(dc)
return SuccessTaskResponse(self.request,
ser.data,
obj=ns,
status=status.HTTP_201_CREATED,
detail_dict=ser.detail_dict(),
msg=LOG_STORAGE_ATTACH)
def post(self):
dc, net = self.request.dc, self.net
if net.dc.filter(id=dc.id).exists():
raise ObjectAlreadyExists(model=Subnet)
ser = NetworkSerializer(self.request, net)
net.dc.add(dc)
res = SuccessTaskResponse(self.request,
ser.data,
obj=net,
status=status.HTTP_201_CREATED,
detail_dict=ser.detail_dict(),
msg=LOG_NETWORK_ATTACH)
self._remove_dc_binding(res)
return res
def post(self):
dc, domain = self.request.dc, self.domain
if DomainDc.objects.filter(dc=dc, domain_id=domain.id).exists():
raise ObjectAlreadyExists(model=Domain)
ser = self.serializer(self.request, domain)
DomainDc.objects.create(dc=dc, domain_id=domain.id)
res = SuccessTaskResponse(self.request,
ser.data,
obj=domain,
status=status.HTTP_201_CREATED,
detail_dict=ser.detail_dict(),
msg=LOG_DOMAIN_ATTACH)
self._remove_dc_binding(res)
return res
def post(self):
dc, vmt = self.request.dc, self.vmt
if vmt.dc.filter(id=dc.id).exists():
raise ObjectAlreadyExists(model=VmTemplate)
ser = self.serializer(self.request, vmt)
vmt.dc.add(dc)
res = SuccessTaskResponse(self.request,
ser.data,
obj=vmt,
status=status.HTTP_201_CREATED,
detail_dict=ser.detail_dict(),
msg=LOG_TEMPLATE_ATTACH)
self._remove_dc_binding(res)
return res
def post(self):
dc, group = self.dc, self.role
if group.dc_set.filter(id=dc.id).exists():
raise ObjectAlreadyExists(model=Role)
ser = self.serializer(self.request, group)
group.dc_set.add(dc)
res = SuccessTaskResponse(self.request,
ser.data,
obj=group,
status=status.HTTP_201_CREATED,
detail_dict=ser.detail_dict(),
msg=LOG_GROUP_ATTACH)
self._remove_dc_binding(res)
self._remove_user_dc_binding(res)
return res
def post(self):
self._check_node()
ns, img = self.ns, self.img
if img.nodestorage_set.filter(id=ns.id).exists():
raise ObjectAlreadyExists(model=Image)
try:
self._check_platform_version()
except PreconditionRequired as exc:
raise exc
except Exception as exc:
# An error in this check should not stop us - fail silently
logger.exception(exc)
return self._run_execute(
LOG_IMG_IMPORT,
'imgadm import -q -P %s %s 2>&1' % (ns.zpool, img.uuid),
img.IMPORTING)
def harvest_vm(request, hostname, data=None):
"""
Fetch server metadata from compute node and create server(s) in the DB
(:http:post:`POST </node/(hostname)/vm-harvest>`).
.. http:post:: /node/(hostname)/vm-harvest
:DC-bound?:
* |dc-yes|
:Permissions:
* |SuperAdmin|
:Asynchronous?:
* |async-yes|
:arg hostname: **required** - Node hostname
:type hostname: string
:arg data.vm: Optional server uuid. Fetch all servers defined on the compute node if not provided
:type data.vm: string
:status 200: SUCCESS
:status 201: PENDING
:status 400: FAILURE
:status 403: Forbidden
:status 404: Node not found
:status 406: VM already exists
:status 423: Node is not operational
"""
node = get_node(request,
hostname,
dc=request.dc,
exists_ok=True,
noexists_fail=True)
vm = data.get('vm', None)
if vm:
if Vm.objects.filter(uuid=vm).exists():
raise ObjectAlreadyExists(model=Vm)
if node.status != node.ONLINE:
raise NodeIsNotOperational
return VmHarvestView(request, node, vm_uuid=vm).post()
def post(self):
dc, group = self.dc, self.role
if group.dc_set.filter(id=dc.id).exists():
raise ObjectAlreadyExists(model=Role)
ser = self.serializer(self.request, group)
group.dc_set.add(dc)
connection.on_commit(lambda: group_relationship_changed.send(
group_name=group.name, dc_name=dc.name))
res = SuccessTaskResponse(self.request,
ser.data,
obj=group,
status=status.HTTP_201_CREATED,
detail_dict=ser.detail_dict(),
msg=LOG_GROUP_ATTACH)
self._remove_dc_binding(res)
self._remove_user_dc_binding(res)
self._update_affected_users()
return res
def post(self):
img = self.get_image()
uuid = img['uuid']
data = self.data
data['manifest_url'] = self.repo.get_image_manifest_url(uuid)
data.pop('file_url', None)
name = data.get('name', None)
if not name:
name = data['name'] = img['name']
# Although this is also checked inside the image_manage, doing it here is better because:
# - checking the uniqueness of the UUID is done differently in image_manage and the result is not a 406 error
# - it is faster - in case the name/uuid is not unique we don't have to call another view
if Image.objects.filter(Q(uuid=uuid) | Q(name=name)).exists():
raise ObjectAlreadyExists(model=Image)
return call_api_view(self.request,
'POST',
image_manage,
name,
data=data)
