/ - Diff - Synnefo - Greek Research and Technology Network's projects

Revision 23808592

     from snf_django.lib.astakos import UserCache
     from synnefo.db.models import VirtualMachine, Network, Backend
     from synnefo.plankton.utils import image_backend
     from synnefo.plankton.backend import PlanktonBackend
     from synnefo.logic import backend as backend_mod
-...
         def get_image(self, imageid, userid):
             if not imageid in self.images:
                 try:
                     with image_backend(userid) as ib:
                     with PlanktonBackend(userid) as ib:
                         image = ib.get_image(imageid)
                     properties = image.get("properties")
                     os = properties.get("os",

     from snf_django.lib import api
     from snf_django.lib.api import faults, utils
     from synnefo.api import util
     from synnefo.plankton.utils import image_backend
     from synnefo.plankton import backend
     log = getLogger(__name__)
-...
         log.debug('list_images detail=%s', detail)
         since = utils.isoparse(request.GET.get('changes-since'))
         with image_backend(request.user_uniq) as backend:
             images = backend.list_images()
         with backend.PlanktonBackend(request.user_uniq) as b:
             images = b.list_images()
             if since:
                 updated_since = lambda img: date_parse(img["updated_at"]) >= since
                 images = ifilter(updated_since, images)
-...
         #                       overLimit (413)
         log.debug('get_image_details %s', image_id)
         with image_backend(request.user_uniq) as backend:
             image = backend.get_image(image_id)
         with backend.PlanktonBackend(request.user_uniq) as b:
             image = b.get_image(image_id)
         reply = image_to_dict(image)
         if request.serialization == 'xml':
-...
         #                       overLimit (413)
         log.info('delete_image %s', image_id)
         with image_backend(request.user_uniq) as backend:
             backend.unregister(image_id)
         with backend.PlanktonBackend(request.user_uniq) as b:
             b.unregister(image_id)
         log.info('User %s deleted image %s', request.user_uniq, image_id)
         return HttpResponse(status=204)
-...
         #                       overLimit (413)
         log.debug('list_image_metadata %s', image_id)
         with image_backend(request.user_uniq) as backend:
             image = backend.get_image(image_id)
         with backend.PlanktonBackend(request.user_uniq) as b:
             image = b.get_image(image_id)
         metadata = image['properties']
         return util.render_metadata(request, metadata, use_values=False,
                                     status=200)
-...
         req = utils.get_request_dict(request)
         log.info('update_image_metadata %s %s', image_id, req)
         with image_backend(request.user_uniq) as backend:
             image = backend.get_image(image_id)
         with backend.PlanktonBackend(request.user_uniq) as b:
             image = b.get_image(image_id)
             try:
                 metadata = req['metadata']
                 assert isinstance(metadata, dict)
-...
             properties = image['properties']
             properties.update(metadata)
             backend.update_metadata(image_id, dict(properties=properties))
             b.update_metadata(image_id, dict(properties=properties))
         return util.render_metadata(request, properties, status=201)
-...
         #                       overLimit (413)
         log.debug('get_image_metadata_item %s %s', image_id, key)
         with image_backend(request.user_uniq) as backend:
             image = backend.get_image(image_id)
         with backend.PlanktonBackend(request.user_uniq) as b:
             image = b.get_image(image_id)
         val = image['properties'].get(key)
         if val is None:
             raise faults.ItemNotFound('Metadata key not found.')
-...
             raise faults.BadRequest('Malformed request.')
         val = metadict[key]
         with image_backend(request.user_uniq) as backend:
             image = backend.get_image(image_id)
         with backend.PlanktonBackend(request.user_uniq) as b:
             image = b.get_image(image_id)
             properties = image['properties']
             properties[key] = val
             backend.update_metadata(image_id, dict(properties=properties))
             b.update_metadata(image_id, dict(properties=properties))
         return util.render_meta(request, {key: val}, status=201)
-...
         #                       overLimit (413),
         log.info('delete_image_metadata_item %s %s', image_id, key)
         with image_backend(request.user_uniq) as backend:
             image = backend.get_image(image_id)
         with backend.PlanktonBackend(request.user_uniq) as b:
             image = b.get_image(image_id)
             properties = image['properties']
             properties.pop(key, None)
             backend.update_metadata(image_id, dict(properties=properties))
             b.update_metadata(image_id, dict(properties=properties))
         return HttpResponse(status=204)

     from mock import patch
     from functools import wraps
     compute_path = get_service_path(cyclades_services, 'compute',
                                     version='v2.0')
     IMAGES_URL = join_urls(compute_path, "images/")
     def assert_backend_closed(func):
         """Decorator for ensuring that ImageBackend is returned to pool."""
         """Decorator for ensuring that PlanktonBackend is returned to pool."""
         @wraps(func)
         def wrapper(self, backend):
             result = func(self, backend)
-...
         return wrapper
     class ComputeAPITest(BaseAPITest):
         def setUp(self, *args, **kwargs):
             super(ComputeAPITest, self).setUp(*args, **kwargs)
             self.compute_path = get_service_path(cyclades_services, 'compute',
                                                  version='v2.0')
         def myget(self, path, *args, **kwargs):
             path = join_urls(self.compute_path, path)
             return self.get(path, *args, **kwargs)
         def myput(self, path, *args, **kwargs):
             path = join_urls(self.compute_path, path)
             return self.put(path, *args, **kwargs)
         def mypost(self, path, *args, **kwargs):
             path = join_urls(self.compute_path, path)
             return self.post(path, *args, **kwargs)
         def mydelete(self, path, *args, **kwargs):
             path = join_urls(self.compute_path, path)
             return self.delete(path, *args, **kwargs)
     @patch('synnefo.plankton.backend.ImageBackend')
     class ImageAPITest(ComputeAPITest):
     @patch('synnefo.plankton.backend.PlanktonBackend')
     class ImageAPITest(BaseAPITest):
         @assert_backend_closed
         def test_create_image(self, mimage):
             """Test that create image is not implemented"""
             response = self.mypost('images/', 'user', json.dumps(''), 'json')
             response = self.post(IMAGES_URL, 'user', json.dumps(''), 'json')
             self.assertEqual(response.status_code, 501)
         @assert_backend_closed
-...
             images = [{'id': 1, 'name': 'image-1'},
                       {'id': 2, 'name': 'image-2'},
                       {'id': 3, 'name': 'image-3'}]
             mimage().list_images.return_value = images
             response = self.myget('images', 'user')
             mimage().__enter__().list_images.return_value = images
             response = self.get(IMAGES_URL, 'user')
             self.assertSuccess(response)
             api_images = json.loads(response.content)['images']
             self.assertEqual(images, api_images)
-...
                        'created': '2012-11-26T11:52:54+00:00',
                        'updated': '2012-12-26T11:52:54+00:00',
                        'metadata': {}}]
             mimage().list_images.return_value = images
             response = self.myget('images/detail', 'user')
             mimage().__enter__().list_images.return_value = images
             response = self.get(join_urls(IMAGES_URL, "detail"), 'user')
             self.assertSuccess(response)
             api_images = json.loads(response.content)['images']
             self.assertEqual(len(result_images), len(api_images))
-...
                        'updated_at': new_time.isoformat(),
                        'deleted_at': new_time.isoformat(),
                        'properties': ''}]
             mimage().list_images.return_value = images
             mimage().__enter__().list_images.return_value = images
             response =\
                 self.myget('images/detail?changes-since=%sUTC' % new_time)
                 self.get(join_urls(IMAGES_URL, 'detail?changes-since=%sUTC' %
                                    new_time))
             self.assertSuccess(response)
             api_images = json.loads(response.content)['images']
             self.assertEqual(1, len(api_images))
-...
                        'user_id': 'user1',
                        'tenant_id': 'user1',
                        'metadata': {'foo': 'bar'}}
             mimage.return_value.get_image.return_value = image
             response = self.myget('images/42', 'user')
             mimage().__enter__().get_image.return_value = image
             response = self.get(join_urls(IMAGES_URL, "42"), 'user')
             self.assertSuccess(response)
             api_image = json.loads(response.content)['image']
             api_image.pop("links")
             self.assertEqual(api_image, result_image)
         @assert_backend_closed
         def test_invalid_image(self, mimage):
             mimage.return_value.get_image.side_effect = faults.ItemNotFound('Image not found')
             response = self.myget('images/42', 'user')
             mimage().__enter__().get_image.side_effect = \
                 faults.ItemNotFound('Image not found')
             response = self.get(join_urls(IMAGES_URL, "42"), 'user')
             self.assertItemNotFound(response)
         @assert_backend_closed
         def test_delete_image(self, mimage):
             response = self.mydelete("images/42", "user")
             response = self.delete(join_urls(IMAGES_URL, "42"), 'user')
             self.assertEqual(response.status_code, 204)
             mimage.return_value.unregister.assert_called_once_with('42')
             mimage.return_value._delete.assert_not_called('42')
             mimage().__enter__().unregister.assert_called_once_with('42')
         @assert_backend_closed
         def test_catch_wrong_api_paths(self, *args):
             response = self.myget('nonexistent')
             response = self.get(join_urls(IMAGES_URL, 'nonexistent/lala/foo'))
             self.assertEqual(response.status_code, 400)
             try:
                 error = json.loads(response.content)
-...
         @assert_backend_closed
         def test_method_not_allowed(self, *args):
             # /images/ allows only POST, GET
             response = self.myput('images', '', '')
             response = self.put(IMAGES_URL, '', '')
             self.assertMethodNotAllowed(response)
             response = self.mydelete('images')
             response = self.delete(IMAGES_URL, '')
             self.assertMethodNotAllowed(response)
             # /images/<imgid>/ allows only GET, DELETE
             response = self.mypost("images/42")
             self.assertMethodNotAllowed(response)
             response = self.myput('images/42', '', '')
             self.assertMethodNotAllowed(response)
             # /images/<imgid>/metadata/ allows only POST, GET
             response = self.myput('images/42/metadata', '', '')
             response = self.post(join_urls(IMAGES_URL, "42"), 'user')
             self.assertMethodNotAllowed(response)
             response = self.mydelete('images/42/metadata')
             response = self.put(join_urls(IMAGES_URL, "42"), 'user')
             self.assertMethodNotAllowed(response)
             # /images/<imgid>/metadata/ allows only POST, GET
             response = self.myput('images/42/metadata', '', '')
             response = self.put(join_urls(IMAGES_URL, "42", "metadata"), 'user')
             self.assertMethodNotAllowed(response)
             response = self.mydelete('images/42/metadata')
             response = self.delete(join_urls(IMAGES_URL, "42", "metadata"), 'user')
             self.assertMethodNotAllowed(response)
             # /images/<imgid>/metadata/<key> allows only PUT, GET, DELETE
             response = self.mypost('images/42/metadata/foo')
             response = self.post(join_urls(IMAGES_URL, "42", "metadata", "foo"),
                                  'user')
             self.assertMethodNotAllowed(response)
     @patch('synnefo.plankton.backend.ImageBackend')
     class ImageMetadataAPITest(ComputeAPITest):
     @patch('synnefo.plankton.backend.PlanktonBackend')
     class ImageMetadataAPITest(BaseAPITest):
         def setUp(self):
             self.image = {'id': 42,
                      'name': 'image-1',
-...
         @assert_backend_closed
         def test_list_metadata(self, backend):
             backend.return_value.get_image.return_value = self.image
             response = self.myget('images/42/metadata', 'user')
             backend().__enter__().get_image.return_value = self.image
             response = self.get(join_urls(IMAGES_URL, '42/metadata'), 'user')
             self.assertSuccess(response)
             meta = json.loads(response.content)['metadata']
             self.assertEqual(meta, self.image['properties'])
         @assert_backend_closed
         def test_get_metadata(self, backend):
             backend.return_value.get_image.return_value = self.image
             response = self.myget('images/42/metadata/foo', 'user')
             backend().__enter__().get_image.return_value = self.image
             response = self.get(join_urls(IMAGES_URL, '42/metadata/foo'), 'user')
             self.assertSuccess(response)
             meta = json.loads(response.content)['meta']
             self.assertEqual(meta['foo'], 'bar')
         @assert_backend_closed
         def test_get_invalid_metadata(self, backend):
             backend.return_value.get_image.return_value = self.image
             response = self.myget('images/42/metadata/not_found', 'user')
             backend().__enter__().get_image.return_value = self.image
             response = self.get(join_urls(IMAGES_URL, '42/metadata/not_found'),
                                 'user')
             self.assertItemNotFound(response)
         def test_delete_metadata_item(self, backend):
             backend.return_value.get_image.return_value = self.image
             response = self.mydelete('images/42/metadata/foo', 'user')
             backend().__enter__().get_image.return_value = self.image
             response = self.delete(join_urls(IMAGES_URL, '42/metadata/foo'),
                                    'user')
             self.assertEqual(response.status_code, 204)
             backend.return_value.update_metadata.assert_called_once_with('42', {'properties': {'foo2':
                                                         'bar2'}})
             backend().__enter__().update_metadata\
                    .assert_called_once_with('42', {'properties': {'foo2': 'bar2'}})
         @assert_backend_closed
         def test_create_metadata_item(self, backend):
             backend.return_value.get_image.return_value = self.image
             backend().__enter__().get_image.return_value = self.image
             request = {'meta': {'foo3': 'bar3'}}
             response = self.myput('images/42/metadata/foo3', 'user',
                                   json.dumps(request), 'json')
             response = self.put(join_urls(IMAGES_URL, '42/metadata/foo3'), 'user',
                                 json.dumps(request), 'json')
             self.assertEqual(response.status_code, 201)
             backend.return_value.update_metadata.assert_called_once_with('42',
             backend().__enter__().update_metadata.assert_called_once_with('42',
                     {'properties':
                         {'foo': 'bar', 'foo2': 'bar2', 'foo3': 'bar3'}})
         @assert_backend_closed
         def test_create_metadata_malformed_1(self, backend):
             backend.return_value.get_image.return_value = self.image
             backend().__enter__().get_image.return_value = self.image
             request = {'met': {'foo3': 'bar3'}}
             response = self.myput('images/42/metadata/foo3', 'user',
                                   json.dumps(request), 'json')
             response = self.put(join_urls(IMAGES_URL, '42/metadata/foo3'), 'user',
                                 json.dumps(request), 'json')
             self.assertBadRequest(response)
         @assert_backend_closed
         def test_create_metadata_malformed_2(self, backend):
             backend.return_value.get_image.return_value = self.image
             backend().__enter__().get_image.return_value = self.image
             request = {'metadata': [('foo3', 'bar3')]}
             response = self.myput('images/42/metadata/foo3', 'user',
                                   json.dumps(request), 'json')
             response = self.put(join_urls(IMAGES_URL, '42/metadata/foo3'), 'user',
                                 json.dumps(request), 'json')
             self.assertBadRequest(response)
         @assert_backend_closed
         def test_create_metadata_malformed_3(self, backend):
             backend.return_value.get_image.return_value = self.image
             backend().__enter__().get_image.return_value = self.image
             request = {'met': {'foo3': 'bar3', 'foo4': 'bar4'}}
             response = self.myput('images/42/metadata/foo3', 'user',
                                     json.dumps(request), 'json')
             response = self.put(join_urls(IMAGES_URL, '42/metadata/foo3'), 'user',
                                 json.dumps(request), 'json')
             self.assertBadRequest(response)
         @assert_backend_closed
         def test_create_metadata_malformed_4(self, backend):
             backend.return_value.get_image.return_value = self.image
             backend().__enter__().get_image.return_value = self.image
             request = {'met': {'foo3': 'bar3'}}
             response = self.myput('images/42/metadata/foo4', 'user',
                                   json.dumps(request), 'json')
             response = self.put(join_urls(IMAGES_URL, '42/metadata/foo4'), 'user',
                                 json.dumps(request), 'json')
             self.assertBadRequest(response)
         @assert_backend_closed
         def test_update_metadata_item(self, backend):
             backend.return_value.get_image.return_value = self.image
             backend().__enter__().get_image.return_value = self.image
             request = {'metadata': {'foo': 'bar_new', 'foo4': 'bar4'}}
             response = self.mypost('images/42/metadata', 'user',
                                    json.dumps(request), 'json')
             response = self.post(join_urls(IMAGES_URL, '42/metadata'), 'user',
                                  json.dumps(request), 'json')
             self.assertEqual(response.status_code, 201)
             backend.return_value.update_metadata.assert_called_once_with('42',
             backend().__enter__().update_metadata.assert_called_once_with('42',
                     {'properties':
                         {'foo': 'bar_new', 'foo2': 'bar2', 'foo4': 'bar4'}
                     })
         @assert_backend_closed
         def test_update_metadata_malformed(self, backend):
             backend.return_value.get_image.return_value = self.image
             backend().__enter__().get_image.return_value = self.image
             request = {'meta': {'foo': 'bar_new', 'foo4': 'bar4'}}
             response = self.mypost('images/42/metadata', 'user',
                                    json.dumps(request), 'json')
             response = self.post(join_urls(IMAGES_URL, '42/metadata'), 'user',
                                  json.dumps(request), 'json')
             self.assertBadRequest(response)

                                    Network, NetworkInterface, SecurityGroup,
                                    BridgePoolTable, MacPrefixPoolTable, IPAddress,
                                    IPPoolTable)
     from synnefo.plankton.utils import image_backend
     from synnefo.plankton.backend import PlanktonBackend
     from synnefo.cyclades_settings import cyclades_services, BASE_HOST
     from synnefo.lib.services import get_service_path
-...
     def get_image(image_id, user_id):
         """Return an Image instance or raise ItemNotFound."""
         with image_backend(user_id) as backend:
         with PlanktonBackend(user_id) as backend:
             return backend.get_image(image_id)

     # Copyright 2011-2013 GRNET S.A. All rights reserved.
     # Copyright 2011-2014 GRNET S.A. All rights reserved.
+    #
     # Redistribution and use in source and binary forms, with or
-...
     """
     import json
     import warnings
     import logging
     import os
     from time import time, gmtime, strftime
     from functools import wraps
     from operator import itemgetter
     from collections import namedtuple
     from django.conf import settings
     from django.utils import importlib
     from pithos.backends.base import NotAllowedError, VersionNotExists
     from pithos.backends.base import NotAllowedError, VersionNotExists, QuotaError
     from synnefo.util.text import uenc
     from copy import deepcopy
     from snf_django.lib.api import faults
     Location = namedtuple("ObjectLocation", ["account", "container", "path"])
     logger = logging.getLogger(__name__)
-...
         return _pithos_backend_pool.pool_get()
     def create_url(account, container, name):
         assert "/" not in account, "Invalid account"
         assert "/" not in container, "Invalid container"
         return "pithos://%s/%s/%s" % (account, container, name)
     def split_url(url):
         """Returns (accout, container, object) from a url string"""
         try:
             assert(isinstance(url, basestring))
             t = url.split('/', 4)
             assert t[0] == "pithos:", "Invalid url"
             assert len(t) == 5, "Invalid url"
             return t[2:5]
         except AssertionError:
             raise InvalidLocation("Invalid location '%s" % url)
     def format_timestamp(t):
         return strftime('%Y-%m-%d %H:%M:%S', gmtime(t))
     def handle_backend_exceptions(func):
     def handle_pithos_backend(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
             try:
                 return func(*args, **kwargs)
             except NotAllowedError:
                 raise Forbidden
             except NameError:
                 raise ImageNotFound
             except VersionNotExists:
                 raise ImageNotFound
         return wrapper
     def commit_on_success(func):
         def wrapper(self, *args, **kwargs):
             backend = self.backend
             backend.pre_exec()
             commit = False
             try:
                 ret = func(self, *args, **kwargs)
             except:
                 backend.post_exec(False)
                 raise
             except NotAllowedError:
                 raise faults.Forbidden
             except (NameError, VersionNotExists):
                 raise faults.ItemNotFound
             except (AssertionError, ValueError):
                 raise faults.BadRequest
             except QuotaError:
                 raise faults.OverLimit
             else:
                 backend.post_exec(True)
                 commit = True
             finally:
                 backend.post_exec(commit)
             return ret
         return wrapper
     class ImageBackend(object):
     class PlanktonBackend(object):
         """A wrapper arround the pithos backend to simplify image handling."""
         def __init__(self, user):
             self.user = user
             original_filters = warnings.filters
             warnings.simplefilter('ignore')         # Suppress SQLAlchemy warnings
             self.backend = get_pithos_backend()
             warnings.filters = original_filters     # Restore warnings
         def close(self):
             """Close PithosBackend(return to pool)"""
             self.backend.close()
         @handle_backend_exceptions
         @commit_on_success
         def get_image(self, image_uuid):
             """Retrieve information about an image."""
             image_url = self._get_image_url(image_uuid)
             return self._get_image(image_url)
         def __enter__(self):
             return self
         def __exit__(self, exc_type, exc_val, exc_tb):
             self.close()
             self.backend = None
             return False
         @handle_pithos_backend
         def get_image(self, uuid):
             return self._get_image(uuid)
         def _get_image(self, uuid):
             location, metadata = self._get_raw_metadata(uuid)
             permissions = self._get_raw_permissions(uuid, location)
             return image_to_dict(location, metadata, permissions)
         @handle_pithos_backend
         def add_property(self, uuid, key, value):
             location, _ = self._get_raw_metadata(uuid)
             properties = self._prefix_properties({key: value})
             self._update_metadata(uuid, location, properties, replace=False)
         @handle_pithos_backend
         def remove_property(self, uuid, key):
             location, _ = self._get_raw_metadata(uuid)
             # Use empty string to delete a property
             properties = self._prefix_properties({key: ""})
             self._update_metadata(uuid, location, properties, replace=False)
         @handle_pithos_backend
         def update_properties(self, uuid, properties):
             location, _ = self._get_raw_metadata(uuid)
             properties = self._prefix_properties(properties)
             self._update_metadata(uuid, location, properties, replace=False)
         @staticmethod
         def _prefix_properties(properties):
             """Add property prefix to properties."""
             return dict([(PROPERTY_PREFIX + k, v) for k, v in properties.items()])
         @staticmethod
         def _unprefix_properties(properties):
             """Remove property prefix from properties."""
             return dict([(k.replace(PROPERTY_PREFIX, "", 1), v)
                          for k, v in properties.items()])
         @staticmethod
         def _prefix_metadata(metadata):
             """Add plankton prefix to metadata."""
             return dict([(PLANKTON_PREFIX + k, v) for k, v in metadata.items()])
         @staticmethod
         def _unprefix_metadata(metadata):
             """Remove plankton prefix from metadata."""
             return dict([(k.replace(PLANKTON_PREFIX, "", 1), v)
                          for k, v in metadata.items()])
         @handle_pithos_backend
         def update_metadata(self, uuid, metadata):
             location, _ = self._get_raw_metadata(uuid)
         def _get_image_url(self, image_uuid):
             """Get the Pithos url that corresponds to an image UUID."""
             account, container, name = self.backend.get_uuid(self.user, image_uuid)
             return create_url(account, container, name)
             is_public = metadata.pop("is_public", None)
             if is_public is not None:
                 self._set_public(uuid, location, public=is_public)
         def _get_image(self, image_url):
             """Get information about an Image.
             # Each property is stored as a separate prefixed metadata
             meta = deepcopy(metadata)
             properties = meta.pop("properties", {})
             meta.update(self._prefix_properties(properties))
             Get all available information about an Image.
             """
             account, container, name = split_url(image_url)
             try:
                 meta = self._get_meta(image_url)
                 meta["deleted"] = ""
             except NameError:
                 versions = self.backend.list_versions(self.user, account,
                                                       container, name)
                 if not versions:
                     raise Exception("Image without versions %s" % image_url)
                 # Object was deleted, use the latest version
                 version, timestamp = versions[-1]
                 meta = self._get_meta(image_url, version)
                 meta["deleted"] = timestamp
             # XXX: Check that an object is a plankton image! PithosBackend will
             # return common metadata for an object, even if it has no metadata in
             # plankton domain. All images must have a name, so we check if a file
             # is an image by checking if they are having an image name.
             if PLANKTON_PREFIX + 'name' not in meta:
                 raise ImageNotFound
             permissions = self._get_permissions(image_url)
             return image_to_dict(image_url, meta, permissions)
         def _get_meta(self, image_url, version=None):
             """Get object's metadata."""
             account, container, name = split_url(image_url)
             return self.backend.get_object_meta(self.user, account, container,
                                                 name, PLANKTON_DOMAIN, version)
         def _update_meta(self, image_url, meta, replace=False):
             """Update object's metadata."""
             account, container, name = split_url(image_url)
             prefixed = [(PLANKTON_PREFIX + uenc(k), uenc(v))
                         for k, v in meta.items()
                         if k in PLANKTON_META or k.startswith(PROPERTY_PREFIX)]
             prefixed = dict(prefixed)
             for k, v in prefixed.items():
             self._update_metadata(uuid, location, metadata=meta, replace=False)
             return self._get_image(uuid)
         def _update_metadata(self, uuid, location, metadata, replace=False):
             _prefixed_metadata = self._prefix_metadata(metadata)
             prefixed = {}
             for k, v in _prefixed_metadata.items():
                 # Encode to UTF-8
                 k, v = uenc(k), uenc(v)
                 # Check the length of key/value
                 if len(k) > 128:
                     raise InvalidMetadata('Metadata keys should be less than %s '
                                           'characters' % MAX_META_KEY_LENGTH)
                     raise faults.BadRequest('Metadata keys should be less than %s'
                                             ' characters' % MAX_META_KEY_LENGTH)
                 if len(v) > 256:
                     raise InvalidMetadata('Metadata values should be less than %s '
                                           'characters.' % MAX_META_VALUE_LENGTH)
                     raise faults.BadRequest('Metadata values should be less than'
                                             ' %scharacters.'
                                             % MAX_META_VALUE_LENGTH)
                 prefixed[k] = v
             self.backend.update_object_meta(self.user, account, container, name,
             account, container, path = location
             self.backend.update_object_meta(self.user, account, container, path,
                                             PLANKTON_DOMAIN, prefixed, replace)
             logger.debug("User '%s' updated image '%s', meta: '%s'", self.user,
                          image_url, prefixed)
         def _get_permissions(self, image_url):
             """Get object's permissions."""
             account, container, name = split_url(image_url)
             _a, path, permissions = \
                 self.backend.get_object_permissions(self.user, account, container,
                                                     name)
             if path is None and permissions != {}:
                 logger.warning("Image '%s' got permissions '%s' from 'None' path.",
                                image_url, permissions)
                 raise Exception("Database Inconsistency Error:"
                                 " Image '%s' got permissions from 'None' path." %
                                 image_url)
             return permissions
         def _update_permissions(self, image_url, permissions):
             """Update object's permissions."""
             account, container, name = split_url(image_url)
             self.backend.update_object_permissions(self.user, account, container,
                                                    name, permissions)
             logger.debug("User '%s' updated image '%s', permissions: '%s'",
                          self.user, image_url, permissions)
             logger.debug("User '%s' updated image '%s', metadata: '%s'", self.user,
                          uuid, prefixed)
         @handle_backend_exceptions
         @commit_on_success
         def unregister(self, image_uuid):
             """Unregister an image.
         def _get_raw_metadata(self, uuid, version=None, check_image=True):
             """Get info and metadata in Plankton doamin for the Pithos object.
             Unregister an image, by removing all metadata from the Pithos
             file that exist in the PLANKTON_DOMAIN.
             Return the location and the metadata of the Pithos object.
             If 'check_image' is set, check that the Pithos object is a registered
             Plankton Image.
             """
             image_url = self._get_image_url(image_uuid)
             self._get_image(image_url)  # Assert that it is an image
             # Unregister the image by removing all metadata from domain
             # 'PLANKTON_DOMAIN'
             meta = {}
             self._update_meta(image_url, meta, True)
             logger.debug("User '%s' deleted image '%s'", self.user, image_url)
         @handle_backend_exceptions
         @commit_on_success
         def add_user(self, image_uuid, add_user):
             """Add a user as an image member.
             Update read permissions of Pithos file, to include the specified user.
             """
             image_url = self._get_image_url(image_uuid)
             self._get_image(image_url)  # Assert that it is an image
             permissions = self._get_permissions(image_url)
             # Convert uuid to location
             account, container, path = self.backend.get_uuid(self.user, uuid)
             try:
                 meta = self.backend.get_object_meta(self.user, account, container,
                                                     path, PLANKTON_DOMAIN, version)
                 meta["deleted"] = False
             except NameError:
                 if version is not None:
                     raise
                 versions = self.backend.list_versions(self.user, account,
                                                       container, path)
                 assert(versions), ("Object without versions: %s/%s/%s" %
                                    (account, container, path))
                 # Object was deleted, use the latest version
                 version, timestamp = versions[-1]
                 meta = self.backend.get_object_meta(self.user, account, container,
                                                     path, PLANKTON_DOMAIN, version)
                 meta["deleted"] = True
             if check_image and PLANKTON_PREFIX + "name" not in meta:
                 # Check that object is an image by checking if it has an Image name
                 # in Plankton metadata
                 raise faults.ItemNotFound("Image '%s' does not exist." % uuid)
             return Location(account, container, path), meta
         # Users and Permissions
         @handle_pithos_backend
         def add_user(self, uuid, user):
             assert(isinstance(user, basestring))
             location, _ = self._get_raw_metadata(uuid)
             permissions = self._get_raw_permissions(uuid, location)
             read = set(permissions.get("read", []))
             assert(isinstance(add_user, (str, unicode)))
             read.add(add_user)
             permissions["read"] = list(read)
             self._update_permissions(image_url, permissions)
             if not user in read:
                 read.add(user)
                 permissions["read"] = list(read)
                 self._update_permissions(uuid, location, permissions)
         @handle_backend_exceptions
         @commit_on_success
         def remove_user(self, image_uuid, remove_user):
             """Remove the user from image members.
         @handle_pithos_backend
         def remove_user(self, uuid, user):
             assert(isinstance(user, basestring))
             location, _ = self._get_raw_metadata(uuid)
             permissions = self._get_raw_permissions(uuid, location)
             read = set(permissions.get("read", []))
             if user in read:
                 read.remove(user)
                 permissions["read"] = list(read)
                 self._update_permissions(uuid, location, permissions)
             Remove the specified user from the read permissions of the Pithos file.
         @handle_pithos_backend
         def replace_users(self, uuid, users):
             assert(isinstance(users, list))
             location, _ = self._get_raw_metadata(uuid)
             permissions = self._get_raw_permissions(uuid, location)
             read = set(permissions.get("read", []))
             if "*" in read:  # Retain public permissions
                 users.append("*")
             permissions["read"] = list(users)
             self._update_permissions(uuid, location, permissions)
         @handle_pithos_backend
         def list_users(self, uuid):
             location, _ = self._get_raw_metadata(uuid)
             permissions = self._get_raw_permissions(uuid, location)
             return [user for user in permissions.get('read', []) if user != '*']
             """
             image_url = self._get_image_url(image_uuid)
             self._get_image(image_url)  # Assert that it is an image
             permissions = self._get_permissions(image_url)
         def _set_public(self, uuid, location, public):
             permissions = self._get_raw_permissions(uuid, location)
             assert(isinstance(public, bool))
             read = set(permissions.get("read", []))
             assert(isinstance(remove_user, (str, unicode)))
             try:
                 read.remove(remove_user)
             except ValueError:
                 return  # TODO: User did not have access
             if public and "*" not in read:
                 read.add("*")
             elif not public and "*" in read:
                 read.discard("*")
             permissions["read"] = list(read)
             self._update_permissions(image_url, permissions)
         @handle_backend_exceptions
         @commit_on_success
         def replace_users(self, image_uuid, replace_users):
             """Replace image members.
             Replace the read permissions of the Pithos files with the specified
             users. If image is specified as public, we must preserve * permission.
             """
             image_url = self._get_image_url(image_uuid)
             image = self._get_image(image_url)
             permissions = self._get_permissions(image_url)
             assert(isinstance(replace_users, list))
             permissions["read"] = replace_users
             if image.get("is_public", False):
                 permissions["read"].append("*")
             self._update_permissions(image_url, permissions)
         @handle_backend_exceptions
         @commit_on_success
         def list_users(self, image_uuid):
             """List the image members.
             List the image members, by listing all users that have read permission
             to the corresponding Pithos file.
             """
             image_url = self._get_image_url(image_uuid)
             self._get_image(image_url)  # Assert that it is an image
             permissions = self._get_permissions(image_url)
             return [user for user in permissions.get('read', []) if user != '*']
             self._update_permissions(uuid, location, permissions)
             return permissions
         @handle_backend_exceptions
         @commit_on_success
         def update_metadata(self, image_uuid, metadata):
             """Update Image metadata."""
             image_url = self._get_image_url(image_uuid)
             self._get_image(image_url)  # Assert that it is an image
         def _get_raw_permissions(self, uuid, location):
             account, container, path = location
             _a, path, permissions = \
                 self.backend.get_object_permissions(self.user, account, container,
                                                     path)
             # 'is_public' metadata is translated in proper file permissions
             is_public = metadata.pop("is_public", None)
             if is_public is not None:
                 permissions = self._get_permissions(image_url)
                 read = set(permissions.get("read", []))
                 if is_public:
                     read.add("*")
                 else:
                     read.discard("*")
                 permissions["read"] = list(read)
                 self._update_permissions(image_url, permissions)
             if path is None and permissions != {}:
                 raise Exception("Database Inconsistency Error:"
                                 " Image '%s' got permissions from 'None' path." %
                                 uuid)
             # Extract the properties dictionary from metadata, and store each
             # property as a separeted, prefixed metadata
             properties = metadata.pop("properties", {})
             meta = dict([(PROPERTY_PREFIX + k, v) for k, v in properties.items()])
             # Also add the following metadata
             meta.update(**metadata)
             return permissions
             self._update_meta(image_url, meta)
             image_url = self._get_image_url(image_uuid)
             return self._get_image(image_url)
         def _update_permissions(self, uuid, location, permissions):
             account, container, path = location
             self.backend.update_object_permissions(self.user, account, container,
                                                    path, permissions)
             logger.debug("User '%s' updated image '%s' permissions: '%s'",
                          self.user, uuid, permissions)
         @handle_backend_exceptions
         @commit_on_success
         @handle_pithos_backend
         def register(self, name, image_url, metadata):
             # Validate that metadata are allowed
             if "id" in metadata:
                 raise ValueError("Passing an ID is not supported")
                 raise faults.BadRequest("Passing an ID is not supported")
             store = metadata.pop("store", "pithos")
             if store != "pithos":
                 raise ValueError("Invalid store '%s'. Only 'pithos' store is"
                                  "supported" % store)
                 raise faults.BadRequest("Invalid store '%s'. Only 'pithos' store"
                                         " is supported" % store)
             disk_format = metadata.setdefault("disk_format",
                                               settings.DEFAULT_DISK_FORMAT)
             if disk_format not in settings.ALLOWED_DISK_FORMATS:
                 raise ValueError("Invalid disk format '%s'" % disk_format)
                 raise faults.BadRequest("Invalid disk format '%s'" % disk_format)
             container_format =\
                 metadata.setdefault("container_format",
                                     settings.DEFAULT_CONTAINER_FORMAT)
             if container_format not in settings.ALLOWED_CONTAINER_FORMATS:
                 raise ValueError("Invalid container format '%s'" %
                                  container_format)
             # Validate that 'size' and 'checksum' are valid
             account, container, object = split_url(image_url)
                 raise faults.BadRequest("Invalid container format '%s'" %
                                         container_format)
             meta = self._get_meta(image_url)
             account, container, path = split_url(image_url)
             location = Location(account, container, path)
             meta = self.backend.get_object_meta(self.user, account, container,
                                                 path, PLANKTON_DOMAIN, None)
             uuid = meta["uuid"]
             size = int(metadata.pop('size', meta['bytes']))
             if size != meta['bytes']:
                 raise ValueError("Invalid size")
             # Validate that 'size' and 'checksum'
             size = metadata.pop('size', int(meta['bytes']))
             if not isinstance(size, int) or int(size) != int(meta["bytes"]):
                 raise faults.BadRequest("Invalid 'size' field")
             checksum = metadata.pop('checksum', meta['hash'])
             if checksum != meta['hash']:
                 raise ValueError("Invalid checksum")
             if not isinstance(checksum, basestring) or checksum != meta['hash']:
                 raise faults.BadRequest("Invalid checksum field")
             users = [self.user]
             public = metadata.pop("is_public", False)
             if not isinstance(public, bool):
                 raise faults.BadRequest("Invalid value for 'is_public' metadata")
             if public:
                 users.append("*")
             permissions = {'read': users}
             self._update_permissions(uuid, location, permissions)
             # Each property is stored as a separate prefixed metadata
             meta = deepcopy(metadata)
             properties = meta.pop("properties", {})
             meta.update(self._prefix_properties(properties))
             # Add extra metadata
             meta["name"] = name
             meta["status"] = "AVAILABLE"
             meta['created_at'] = str(time())
             #meta["is_snapshot"] = False
             self._update_metadata(uuid, location, metadata=meta, replace=False)
             logger.debug("User '%s' registered image '%s'('%s')", self.user,
                          uuid, location)
             return self._get_image(uuid)
         @handle_pithos_backend
         def unregister(self, uuid):
             """Unregister an Image.
             Unregister an Image by removing all the metadata in the Plankton
             domain. The Pithos file is not deleted.
             # Fix permissions
             is_public = metadata.pop('is_public', False)
             if is_public:
                 permissions = {'read': ['*']}
             else:
                 permissions = {'read': [self.user]}
             # Extract the properties dictionary from metadata, and store each
             # property as a separeted, prefixed metadata
             properties = metadata.pop("properties", {})
             meta = dict([(PROPERTY_PREFIX + k, v) for k, v in properties.items()])
             # Add creation(register) timestamp as a metadata, to avoid extra
             # queries when retrieving the list of images.
             meta['created_at'] = time()
             # Update rest metadata
             meta.update(name=name, status='available', **metadata)
             # Do the actualy update in the Pithos backend
             self._update_meta(image_url, meta)
             self._update_permissions(image_url, permissions)
             logger.debug("User '%s' created image '%s'('%s')", self.user,
                          image_url, name)
             return self._get_image(image_url)
             """
             location, _ = self._get_raw_metadata(uuid)
             self._update_metadata(uuid, location, metadata={}, replace=True)
             logger.debug("User '%s' unregistered image '%s'", self.user, uuid)
         # List functions
         def _list_images(self, user=None, filters=None, params=None):
             filters = filters or {}
-...
                                                       user=user)
             images = []
             for (location, meta, permissions) in _images:
                 image_url = "pithos://" + location
                 meta["modified"] = meta["version_timestamp"]
                 images.append(image_to_dict(image_url, meta, permissions))
             for (location, metadata, permissions) in _images:
                 location = Location(*location.split("/", 2))
                 images.append(image_to_dict(location, metadata, permissions))
             if params is None:
                 params = {}
             key = itemgetter(params.get('sort_key', 'created_at'))
             reverse = params.get('sort_dir', 'desc') == 'desc'
             images.sort(key=key, reverse=reverse)
             return images
         @commit_on_success
         @handle_pithos_backend
         def list_images(self, filters=None, params=None):
             return self._list_images(user=self.user, filters=filters,
                                      params=params)
         @commit_on_success
         @handle_pithos_backend
         def list_shared_images(self, member, filters=None, params=None):
             images = self._list_images(user=self.user, filters=filters,
                                        params=params)
             is_shared = lambda img: not img["is_public"] and img["owner"] == member
             return filter(is_shared, images)
         @commit_on_success
         @handle_pithos_backend
         def list_public_images(self, filters=None, params=None):
             images = self._list_images(user=None, filters=filters, params=params)
             return filter(lambda img: img["is_public"], images)
         # # Snapshots
         # def list_snapshots(self, user=None):
         #     _snapshots = self.list_images()
         #     return [s for s in _snapshots if s["is_snapshot"]]
         # @handle_pithos_backend
         # def get_snapshot(self, user, snapshot_uuid):
         #     snap = self._get_image(snapshot_uuid)
         #     if snap.get("is_snapshot", False) is False:
         #         raise faults.ItemNotFound("Snapshots '%s' does not exist" %
         #                                   snapshot_uuid)
         #     return snap
         # @handle_pithos_backend
         # def delete_snapshot(self, snapshot_uuid):
         #     self.backend.delete_object_for_uuid(self.user, snapshot_uuid)
         # @handle_pithos_backend
         # def update_status(self, image_uuid, status):
         #     """Update status of snapshot"""
         #     location, _ = self._get_raw_metadata(image_uuid)
         #     properties = {"status": status.upper()}
         #     self._update_metadata(image_uuid, location, properties,
         #     replace=False)
         #     return self._get_image(image_uuid)
     class ImageBackendError(Exception):
         pass
     class ImageNotFound(ImageBackendError):
         pass
     class Forbidden(ImageBackendError):
         pass
     class InvalidMetadata(ImageBackendError):
         pass
     def create_url(account, container, name):
         """Create a Pithos URL from the object info"""
         assert "/" not in account, "Invalid account"
         assert "/" not in container, "Invalid container"
         return "pithos://%s/%s/%s" % (account, container, name)
     class InvalidLocation(ImageBackendError):
         pass
     def split_url(url):
         """Get object info from the Pithos URL"""
         assert(isinstance(url, basestring))
         t = url.split('/', 4)
         assert t[0] == "pithos:", "Invalid url"
         assert len(t) == 5, "Invalid url"
         return t[2:5]
     def image_to_dict(image_url, meta, permissions):
     def image_to_dict(location, metadata, permissions):
         """Render an image to a dictionary"""
         account, container, name = split_url(image_url)
         account, container, name = location
         image = {}
         if PLANKTON_PREFIX + 'name' not in meta:
             logger.warning("Image without Plankton name!! url %s meta %s",
                            image_url, meta)
             image[PLANKTON_PREFIX + "name"] = ""
         image["id"] = meta["uuid"]
         image["location"] = image_url
         image["checksum"] = meta["hash"]
         created = meta.get("created_at", meta["modified"])
         image["created_at"] = format_timestamp(created)
         deleted = meta.get("deleted", None)
         image["deleted_at"] = format_timestamp(deleted) if deleted else ""
         image["updated_at"] = format_timestamp(meta["modified"])
         image["size"] = meta["bytes"]
         image["store"] = "pithos"
         image["id"] = metadata["uuid"]
         image["mapfile"] = metadata["hash"]
         image["checksum"] = metadata["hash"]
         image["location"] = create_url(account, container, name)
         image["size"] = metadata["bytes"]
         image['owner'] = account
         image["store"] = u"pithos"
         #image["is_snapshot"] = metadata.pop(PLANKTON_PREFIX + "is_snapshot",
         #False)
         # Permissions
         image["is_public"] = "*" in permissions.get('read', [])
         users = list(permissions.get("read", []))
         image["is_public"] = "*" in users
         image["users"] = [u for u in users if u != "*"]
         # Timestamps
         updated_at = metadata["version_timestamp"]
         created_at = metadata.get("created_at", updated_at)
         image["created_at"] = format_timestamp(created_at)
         image["updated_at"] = format_timestamp(updated_at)
         if metadata.get("deleted", False):
             image["deleted_at"] = image["updated_at"]
         else:
             image["deleted_at"] = ""
         properties = {}
         for key, val in meta.items():
         for key, val in metadata.items():
             # Get plankton properties
             if key.startswith(PLANKTON_PREFIX):
                 # Remove plankton prefix
                 key = key.replace(PLANKTON_PREFIX, "")
                 # Keep only those in plankton meta
                 # Keep only those in plankton metadata
                 if key in PLANKTON_META:
                     if key != "created_at":
                         # created timestamp is return in 'created_at' field
-...
         backend_module = getattr(settings, 'PLANKTON_BACKEND_MODULE', None)
         if not backend_module:
             # no setting set
             return ImageBackend
             return PlanktonBackend
         parts = backend_module.split(".")
         module = ".".join(parts[:-1])

     from optparse import make_option
     from snf_django.management.utils import pprint_table
     from synnefo.plankton.utils import image_backend
     from synnefo.plankton.backend import PlanktonBackend
     class Command(BaseCommand):
-...
         def handle(self, **options):
             user = options['userid']
             with image_backend(user) as backend:
             with PlanktonBackend(user) as backend:
                 images = backend._list_images(user)
                 images.sort(key=lambda x: x['created_at'], reverse=True)

     # Copyright 2012 GRNET S.A. All rights reserved.
     # Copyright 2012-2014 GRNET S.A. All rights reserved.
+    #
     # Redistribution and use in source and binary forms, with or without
     # modification, are permitted provided that the following conditions
-...
     from django.core.management.base import BaseCommand, CommandError
     from synnefo.plankton.utils import image_backend
     from synnefo.plankton.backend import PlanktonBackend
     from snf_django.management import utils
-...
                 raise CommandError("Please provide an image ID")
             image_id = args[0]
             with image_backend(None) as backend:
                 images = backend._list_images(None)
                 try:
                     image = filter(lambda x: x["id"] == image_id, images)[0]
                 except IndexError:
                     raise CommandError("Image not found. Use snf-manage image-list"
                                        " to get the list of all images.")
             utils.pprint_table(out=self.stdout, table=[image.values()], headers=image.keys(), vertical=True)
             with PlanktonBackend(None) as backend:
                 image = backend.get_image(image_id)
             utils.pprint_table(out=self.stdout, table=[image.values()],
                                headers=image.keys(), vertical=True)

     # Copyright 2012 GRNET S.A. All rights reserved.
     # Copyright 2012-2014 GRNET S.A. All rights reserved.
+    #
     # Redistribution and use in source and binary forms, with or
     # without modification, are permitted provided that the following
-...
     from mock import patch
     from functools import wraps
     from copy import deepcopy
     from decimal import Decimal
     from snf_django.utils.testing import BaseAPITest
     from synnefo.cyclades_settings import cyclades_services
     from synnefo.lib.services import get_service_path
     from synnefo.lib import join_urls
     class PlanktonAPITest(BaseAPITest):
         def setUp(self, *args, **kwargs):
             super(PlanktonAPITest, self).setUp(*args, **kwargs)
             self.api_path = get_service_path(cyclades_services, 'image',
                                                  version='v1.0')
         def myget(self, path, *args, **kwargs):
             path = join_urls(self.api_path, path)
             return self.get(path, *args, **kwargs)
         def myput(self, path, *args, **kwargs):
             path = join_urls(self.api_path, path)
             return self.put(path, *args, **kwargs)
         def mypost(self, path, *args, **kwargs):
             path = join_urls(self.api_path, path)
             return self.post(path, *args, **kwargs)
         def mydelete(self, path, *args, **kwargs):
             path = join_urls(self.api_path, path)
             return self.delete(path, *args, **kwargs)
     FILTERS = ('name', 'container_format', 'disk_format', 'status', 'size_min',
                'size_max')
     PARAMS = ('sort_key', 'sort_dir')
     SORT_KEY_OPTIONS = ('id', 'name', 'status', 'size', 'disk_format',
                         'container_format', 'created_at', 'updated_at')
     SORT_DIR_OPTIONS = ('asc', 'desc')
     LIST_FIELDS = ('status', 'name', 'disk_format', 'container_format', 'size',
                    'id')
     DETAIL_FIELDS = ('name', 'disk_format', 'container_format', 'size', 'checksum',
                      'location', 'created_at', 'updated_at', 'deleted_at',
                      'status', 'is_public', 'owner', 'properties', 'id')
     ADD_FIELDS = ('name', 'id', 'store', 'disk_format', 'container_format', 'size',
                   'checksum', 'is_public', 'owner', 'properties', 'location')
     UPDATE_FIELDS = ('name', 'disk_format', 'container_format', 'is_public',
                      'owner', 'properties', 'status')
     DummyImages = {
      '0786a349-9725-48ec-8b86-8598eefc4043':
      {'checksum': u'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
       u'container_format': u'bare',
       'created_at': '2012-12-04 09:50:20',
       'deleted_at': '',
       u'disk_format': u'diskdump',
       'id': u'0786a349-9725-48ec-8b86-8598eefc4043',
       'is_public': True,
       'location': u'pithos://foo@example.com/container/foo3',
       u'name': u'dummyname',
       'owner': u'foo@example.com',
       'properties': {},
       'size': 500L,
       u'status': u'available',
       'store': 'pithos',
       'updated_at': '2012-12-04 09:50:54'},
      'd8aa85b8-410b-4550-953d-6797572534e6':
      {'checksum': u'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
       u'container_format': u'bare',
       'created_at': '2012-11-26 11:56:42',
       'deleted_at': '',
       u'disk_format': u'diskdump',
       'id': u'd8aa85b8-410b-4550-953d-6797572534e6',
       'is_public': False,
       'location': u'pithos://foo@example.com/container/private',
       u'name': u'dummyname2',
       'owner': u'foo@example.com',
       'properties': {},
       'size': 10000L,
       u'status': u'available',
       'store': 'pithos',
       'updated_at': '2012-11-26 11:57:09'},
      '264fb9ac-2458-421c-b460-6a765a92825c':
      {'checksum': u'0c6d0586744781218672fff2d7ed94cc32efb02a6a8eb589a0628f0e22bd5a7f',
       u'container_format': u'bare',
       'created_at': '2012-11-26 11:52:54',
       'deleted_at': '',
       u'disk_format': u'diskdump',
       'id': u'264fb9ac-2458-421c-b460-6a765a92825c',
       'is_public': True,
       'location': u'pithos://foo@example.com/container/baz.diskdump',
       u'name': u'"dummyname3"',
       'owner': u'foo@example.com',
       'properties': {u'description': u'Debian Squeeze Base System',
                      u'gui': u'No GUI',
                      u'kernel': u'2.6.32',
                      u'os': u'debian',
                      u'osfamily': u'linux',
                      u'root_partition': u'1',
                      u'size': u'451',
                      u'sortorder': u'1',
                      u'users': u'root'},
       'size': 473772032L,
       u'status': u'available',
       'store': 'pithos',
       'updated_at': '2012-11-26 11:55:40'}}
     PLANKTON_URL = get_service_path(cyclades_services, 'image',
                                     version='v1.0')
     IMAGES_URL = join_urls(PLANKTON_URL, "images/")
     def assert_backend_closed(func):
-...
         return wrapper
     @patch("synnefo.plankton.backend.ImageBackend")
     class PlanktonTest(PlanktonAPITest):
         @assert_backend_closed
         def test_list_images(self, backend):
             backend.return_value.list_images.return_value =\
                     deepcopy(DummyImages).values()
             response = self.myget("images/")
             self.assertSuccess(response)
             images = json.loads(response.content)
             for api_image in images:
                 id = api_image['id']
                 pithos_image = dict([(key, val)\
                                     for key, val in DummyImages[id].items()\
                                     if key in LIST_FIELDS])
                 self.assertEqual(api_image, pithos_image)
             backend.return_value\
                     .list_images.assert_called_once_with({}, {'sort_key': 'created_at',
                                                        'sort_dir': 'desc'})
     @patch("synnefo.plankton.backend.get_pithos_backend")
     class PlanktonTest(BaseAPITest):
         def test_register_image(self, backend):
             required = {
                 "HTTP_X_IMAGE_META_NAME": u"TestImage\u2602",
                 "HTTP_X_IMAGE_META_LOCATION": "pithos://4321-4321/images/foo"}
             # Check valid name
             headers = deepcopy(required)
             headers.pop("HTTP_X_IMAGE_META_NAME")
             response = self.post(IMAGES_URL, **headers)
             self.assertBadRequest(response)
             self.assertTrue("name" in response.content)
             headers["HTTP_X_IMAGE_META_NAME"] = ""
             response = self.post(IMAGES_URL, **headers)
             self.assertBadRequest(response)
             self.assertTrue("name" in response.content)
             # Check valid location
             headers = deepcopy(required)
             headers.pop("HTTP_X_IMAGE_META_LOCATION")
             response = self.post(IMAGES_URL, **headers)
             self.assertBadRequest(response)
             self.assertTrue("location" in response.content)
             headers["HTTP_X_IMAGE_META_LOCATION"] = ""
             response = self.post(IMAGES_URL, **headers)
             self.assertBadRequest(response)

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff