Revision 7cc3c7d9
| b/admin/views.py | ||
|---|---|---|
| 136 | 136 |
if not image.format: |
| 137 | 137 |
formats = [''] + formats |
| 138 | 138 |
|
| 139 |
metadata = image.imagemetadata_set.order_by('meta_key')
|
|
| 139 |
metadata = image.metadata.order_by('meta_key')
|
|
| 140 | 140 |
html = render('images_info.html', 'images',
|
| 141 | 141 |
image=image, |
| 142 | 142 |
states=states, |
| ... | ... | |
| 162 | 162 |
keys = request.POST.getlist('key')
|
| 163 | 163 |
vals = request.POST.getlist('value')
|
| 164 | 164 |
meta = dict(zip(keys, vals)) |
| 165 |
image.imagemetadata_set.all().delete()
|
|
| 165 |
image.metadata.all().delete()
|
|
| 166 | 166 |
for key, val in meta.items(): |
| 167 | 167 |
if key: |
| 168 |
image.imagemetadata_set.create(meta_key=key, meta_value=val)
|
|
| 168 |
image.metadata.create(meta_key=key, meta_value=val)
|
|
| 169 | 169 |
|
| 170 | 170 |
_log.info('User %s modified Image %s', request.user.name, image.name)
|
| 171 | 171 |
|
| b/api/images.py | ||
|---|---|---|
| 105 | 105 |
|
| 106 | 106 |
return d |
| 107 | 107 |
|
| 108 |
def metadata_to_dict(image): |
|
| 109 |
image_meta = image.imagemetadata_set.all() |
|
| 110 |
return dict((meta.meta_key, meta.meta_value) for meta in image_meta) |
|
| 111 |
|
|
| 112 | 108 |
|
| 113 | 109 |
@util.api_method('GET')
|
| 114 | 110 |
def list_images(request, detail=False): |
| ... | ... | |
| 220 | 216 |
# overLimit (413) |
| 221 | 217 |
|
| 222 | 218 |
image = util.get_image(image_id, request.user) |
| 223 |
metadata = metadata_to_dict(image)
|
|
| 219 |
metadata = dict((m.meta_key, m.meta_value) for m in image.metadata.all())
|
|
| 224 | 220 |
return util.render_metadata(request, metadata, use_values=True, status=200) |
| 225 | 221 |
|
| 226 | 222 |
@util.api_method('POST')
|
| ... | ... | |
| 241 | 237 |
assert isinstance(metadata, dict) |
| 242 | 238 |
except (KeyError, AssertionError): |
| 243 | 239 |
raise BadRequest('Malformed request.')
|
| 244 |
|
|
| 245 |
updated = {}
|
|
| 246 |
|
|
| 247 |
for key, val in metadata.items(): |
|
| 248 |
try: |
|
| 249 |
meta = ImageMetadata.objects.get(meta_key=key, image=image) |
|
| 250 |
meta.meta_value = val |
|
| 251 |
meta.save() |
|
| 252 |
updated[key] = val |
|
| 253 |
except ImageMetadata.DoesNotExist: |
|
| 254 |
pass # Ignore non-existent metadata |
|
| 255 | 240 |
|
| 256 |
if updated: |
|
| 257 |
image.save() |
|
| 241 |
for key, val in metadata.items(): |
|
| 242 |
meta, created = image.metadata.get_or_create(meta_key=key) |
|
| 243 |
meta.meta_value = val |
|
| 244 |
meta.save() |
|
| 258 | 245 |
|
| 259 |
return util.render_metadata(request, updated, status=201) |
|
| 246 |
image.save() |
|
| 247 |
image_meta = dict((m.meta_key, m.meta_value) for m in image.metadata.all()) |
|
| 248 |
return util.render_metadata(request, image_meta, status=201) |
|
| 260 | 249 |
|
| 261 | 250 |
@util.api_method('GET')
|
| 262 | 251 |
def get_metadata_item(request, image_id, key): |
| b/api/servers.py | ||
|---|---|---|
| 118 | 118 |
return d |
| 119 | 119 |
|
| 120 | 120 |
|
| 121 |
def metadata_to_dict(vm): |
|
| 122 |
vm_meta = vm.virtualmachinemetadata_set.all() |
|
| 123 |
return dict((meta.meta_key, meta.meta_value) for meta in vm_meta) |
|
| 124 |
|
|
| 125 |
|
|
| 126 | 121 |
def vm_to_dict(vm, detail=False): |
| 127 | 122 |
d = dict(id=vm.id, name=vm.name) |
| 128 | 123 |
if detail: |
| ... | ... | |
| 134 | 129 |
d['created'] = util.isoformat(vm.created) |
| 135 | 130 |
d['flavorRef'] = vm.flavor.id |
| 136 | 131 |
d['imageRef'] = vm.sourceimage.id |
| 137 |
|
|
| 138 |
metadata = metadata_to_dict(vm)
|
|
| 132 |
|
|
| 133 |
metadata = dict((m.meta_key, m.meta_value) for m in vm.metadata.all())
|
|
| 139 | 134 |
if metadata: |
| 140 | 135 |
d['metadata'] = {'values': metadata}
|
| 141 | 136 |
|
| ... | ... | |
| 395 | 390 |
# overLimit (413) |
| 396 | 391 |
|
| 397 | 392 |
vm = util.get_vm(server_id, request.user) |
| 398 |
metadata = metadata_to_dict(vm)
|
|
| 393 |
metadata = dict((m.meta_key, m.meta_value) for m in vm.metadata.all())
|
|
| 399 | 394 |
return util.render_metadata(request, metadata, use_values=True, status=200) |
| 400 | 395 |
|
| 401 | 396 |
|
| ... | ... | |
| 417 | 412 |
assert isinstance(metadata, dict) |
| 418 | 413 |
except (KeyError, AssertionError): |
| 419 | 414 |
raise faults.BadRequest("Malformed request")
|
| 420 |
|
|
| 421 |
updated = {}
|
|
| 422 |
|
|
| 423 |
for key, val in metadata.items(): |
|
| 424 |
try: |
|
| 425 |
meta = VirtualMachineMetadata.objects.get(meta_key=key, vm=vm) |
|
| 426 |
meta.meta_value = val |
|
| 427 |
meta.save() |
|
| 428 |
updated[key] = val |
|
| 429 |
except VirtualMachineMetadata.DoesNotExist: |
|
| 430 |
pass # Ignore non-existent metadata |
|
| 431 | 415 |
|
| 432 |
if updated: |
|
| 433 |
vm.save() |
|
| 416 |
for key, val in metadata.items(): |
|
| 417 |
meta, created = vm.metadata.get_or_create(meta_key=key) |
|
| 418 |
meta.meta_value = val |
|
| 419 |
meta.save() |
|
| 434 | 420 |
|
| 435 |
return util.render_metadata(request, updated, status=201) |
|
| 421 |
vm.save() |
|
| 422 |
vm_meta = dict((m.meta_key, m.meta_value) for m in vm.metadata.all()) |
|
| 423 |
return util.render_metadata(request, vm_meta, status=201) |
|
| 436 | 424 |
|
| 437 | 425 |
|
| 438 | 426 |
@util.api_method('GET')
|
| b/api/tests.py | ||
|---|---|---|
| 625 | 625 |
new_metadata = {}
|
| 626 | 626 |
for key in sample(metadata[server_id].keys(), 3): |
| 627 | 627 |
new_metadata[key] = 'New %s value' % key |
| 628 |
response_metadata = self.update_server_metadata(server_id, new_metadata)
|
|
| 629 |
self.assertEqual(response_metadata, new_metadata)
|
|
| 628 |
response_metadata = self.update_server_metadata(server_id, |
|
| 629 |
new_metadata)
|
|
| 630 | 630 |
metadata[server_id].update(new_metadata) |
| 631 |
self.assertEqual(response_metadata, metadata[server_id]) |
|
| 631 | 632 |
self.assertEqual(metadata, self.get_all_server_metadata()) |
| 632 |
|
|
| 633 |
def test_does_not_create(self): |
|
| 634 |
with AssertInvariant(self.get_all_server_metadata) as metadata: |
|
| 635 |
server_id = choice(metadata.keys()) |
|
| 636 |
new_metadata = {'Foo': 'Bar'}
|
|
| 637 |
response_metadata = self.update_server_metadata(server_id, new_metadata) |
|
| 638 |
self.assertEqual(response_metadata, {})
|
|
| 639 |
|
|
| 633 |
|
|
| 640 | 634 |
def test_invalid_data(self): |
| 641 | 635 |
with AssertInvariant(self.get_all_server_metadata) as metadata: |
| 642 | 636 |
server_id = choice(metadata.keys()) |
| ... | ... | |
| 773 | 767 |
for key in sample(metadata[image_id].keys(), 3): |
| 774 | 768 |
new_metadata[key] = 'New %s value' % key |
| 775 | 769 |
response_metadata = self.update_image_metadata(image_id, new_metadata) |
| 776 |
self.assertEqual(response_metadata, new_metadata) |
|
| 777 | 770 |
metadata[image_id].update(new_metadata) |
| 771 |
self.assertEqual(response_metadata, metadata[image_id]) |
|
| 778 | 772 |
self.assertEqual(metadata, self.get_all_image_metadata()) |
| 779 |
|
|
| 780 |
def test_does_not_create(self): |
|
| 781 |
with AssertInvariant(self.get_all_image_metadata) as metadata: |
|
| 782 |
image_id = choice(metadata.keys()) |
|
| 783 |
new_metadata = {'Foo': 'Bar'}
|
|
| 784 |
response_metadata = self.update_image_metadata(image_id, new_metadata) |
|
| 785 |
self.assertEqual(response_metadata, {})
|
|
| 786 |
|
|
| 773 |
|
|
| 787 | 774 |
def test_invalid_data(self): |
| 788 | 775 |
with AssertInvariant(self.get_all_image_metadata) as metadata: |
| 789 | 776 |
image_id = choice(metadata.keys()) |
| b/db/models.py | ||
|---|---|---|
| 140 | 140 |
class ImageMetadata(models.Model): |
| 141 | 141 |
meta_key = models.CharField('Image metadata key name', max_length=50)
|
| 142 | 142 |
meta_value = models.CharField('Image metadata value', max_length=500)
|
| 143 |
image = models.ForeignKey(Image) |
|
| 143 |
image = models.ForeignKey(Image, related_name='metadata')
|
|
| 144 | 144 |
|
| 145 | 145 |
class Meta: |
| 146 | 146 |
unique_together = (('meta_key', 'image'),)
|
| ... | ... | |
| 408 | 408 |
class VirtualMachineMetadata(models.Model): |
| 409 | 409 |
meta_key = models.CharField(max_length=50) |
| 410 | 410 |
meta_value = models.CharField(max_length=500) |
| 411 |
vm = models.ForeignKey(VirtualMachine) |
|
| 411 |
vm = models.ForeignKey(VirtualMachine, related_name='metadata')
|
|
| 412 | 412 |
|
| 413 | 413 |
class Meta: |
| 414 | 414 |
unique_together = (('meta_key', 'vm'),)
|
| b/snf-tools/snf-admin | ||
|---|---|---|
| 431 | 431 |
|
| 432 | 432 |
if not key: |
| 433 | 433 |
metadata = {}
|
| 434 |
for meta in image.imagemetadata_set.order_by('meta_key'):
|
|
| 434 |
for meta in image.metadata.order_by('meta_key'):
|
|
| 435 | 435 |
metadata[meta.meta_key] = meta.meta_value |
| 436 | 436 |
print_dict(metadata) |
| 437 | 437 |
return |
| 438 | 438 |
|
| 439 | 439 |
try: |
| 440 |
meta = image.imagemetadata_set.get(meta_key=key)
|
|
| 440 |
meta = image.metadata.get(meta_key=key)
|
|
| 441 | 441 |
except models.ImageMetadata.DoesNotExist: |
| 442 | 442 |
meta = None |
| 443 | 443 |
|
| ... | ... | |
| 448 | 448 |
|
| 449 | 449 |
if val: |
| 450 | 450 |
if not meta: |
| 451 |
meta = image.imagemetadata_set.create(meta_key=key)
|
|
| 451 |
meta = image.metadata.create(meta_key=key)
|
|
| 452 | 452 |
meta.meta_value = val |
| 453 | 453 |
meta.save() |
| 454 | 454 |
else: |
Also available in: Unified diff