Reserving image before uploading

1 files changed, 10 insertions, 147 deletions

diff --git a/nova/image/glance.py b/nova/image/glance.py
index cc3192e7c..9575574d1 100644
--- a/nova/image/glance.py
+++ b/nova/image/glance.py
@@ -14,9 +14,9 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
-
 """Implementation of an image service that uses Glance as the backend"""
 
+from __future__ import absolute_import
 import httplib
 import json
 import logging
@@ -24,8 +24,6 @@ import urlparse
 
 import webob.exc
 
-from nova.compute import api as compute_api
-from nova import utils
 from nova import flags
 from nova import exception
 import nova.image.service
@@ -33,165 +31,30 @@ import nova.image.service
 FLAGS = flags.FLAGS
 
 
-flags.DEFINE_string('glance_teller_address', 'http://127.0.0.1',
-                    'IP address or URL where Glance\'s Teller service resides')
-flags.DEFINE_string('glance_teller_port', '9191',
-                    'Port for Glance\'s Teller service')
-flags.DEFINE_string('glance_parallax_address', 'http://127.0.0.1',
-                    'IP address or URL where Glance\'s Parallax service '
-                    'resides')
-flags.DEFINE_string('glance_parallax_port', '9292',
-                    'Port for Glance\'s Parallax service')
-
-
-class TellerClient(object):
-
-    def __init__(self):
-        self.address = FLAGS.glance_teller_address
-        self.port = FLAGS.glance_teller_port
-        url = urlparse.urlparse(self.address)
-        self.netloc = url.netloc
-        self.connection_type = {'http': httplib.HTTPConnection,
-                                'https': httplib.HTTPSConnection}[url.scheme]
-
-
-class ParallaxClient(object):
-
-    def __init__(self):
-        self.address = FLAGS.glance_parallax_address
-        self.port = FLAGS.glance_parallax_port
-        url = urlparse.urlparse(self.address)
-        self.netloc = url.netloc
-        self.connection_type = {'http': httplib.HTTPConnection,
-                                'https': httplib.HTTPSConnection}[url.scheme]
-
-    def get_image_index(self):
-        """
-        Returns a list of image id/name mappings from Parallax
-        """
-        try:
-            c = self.connection_type(self.netloc, self.port)
-            c.request("GET", "images")
-            res = c.getresponse()
-            if res.status == 200:
-                # Parallax returns a JSONified dict(images=image_list)
-                data = json.loads(res.read())['images']
-                return data
-            else:
-                logging.warn(_("Parallax returned HTTP error %d from "
-                               "request for /images"), res.status_int)
-                return []
-        finally:
-            c.close()
-
-    def get_image_details(self):
-        """
-        Returns a list of detailed image data mappings from Parallax
-        """
-        try:
-            c = self.connection_type(self.netloc, self.port)
-            c.request("GET", "images/detail")
-            res = c.getresponse()
-            if res.status == 200:
-                # Parallax returns a JSONified dict(images=image_list)
-                data = json.loads(res.read())['images']
-                return data
-            else:
-                logging.warn(_("Parallax returned HTTP error %d from "
-                               "request for /images/detail"), res.status_int)
-                return []
-        finally:
-            c.close()
-
-    def get_image_metadata(self, image_id):
-        """
-        Returns a mapping of image metadata from Parallax
-        """
-        try:
-            c = self.connection_type(self.netloc, self.port)
-            c.request("GET", "images/%s" % image_id)
-            res = c.getresponse()
-            if res.status == 200:
-                # Parallax returns a JSONified dict(image=image_info)
-                data = json.loads(res.read())['image']
-                return data
-            else:
-                # TODO(jaypipes): log the error?
-                return None
-        finally:
-            c.close()
-
-    def add_image_metadata(self, image_metadata):
-        """
-        Tells parallax about an image's metadata
-        """
-        try:
-            c = self.connection_type(self.netloc, self.port)
-            body = json.dumps(image_metadata)
-            c.request("POST", "images", body)
-            res = c.getresponse()
-            if res.status == 200:
-                # Parallax returns a JSONified dict(image=image_info)
-                data = json.loads(res.read())['image']
-                return data['id']
-            else:
-                # TODO(jaypipes): log the error?
-                return None
-        finally:
-            c.close()
-
-    def update_image_metadata(self, image_id, image_metadata):
-        """
-        Updates Parallax's information about an image
-        """
-        try:
-            c = self.connection_type(self.netloc, self.port)
-            body = json.dumps(image_metadata)
-            c.request("PUT", "images/%s" % image_id, body)
-            res = c.getresponse()
-            return res.status == 200
-        finally:
-            c.close()
-
-    def delete_image_metadata(self, image_id):
-        """
-        Deletes Parallax's information about an image
-        """
-        try:
-            c = self.connection_type(self.netloc, self.port)
-            c.request("DELETE", "images/%s" % image_id)
-            res = c.getresponse()
-            return res.status == 200
-        finally:
-            c.close()
-
-
 class GlanceImageService(nova.image.service.BaseImageService):
     """Provides storage and retrieval of disk image objects within Glance."""
 
     def __init__(self):
-        self.teller = TellerClient()
-        self.parallax = ParallaxClient()
+        from glance.client import Client #TODO(sirp): lazy-import glance
+        self.client = Client(FLAGS.glance_host, FLAGS.glance_port)
 
     def index(self, context):
         """
         Calls out to Parallax for a list of images available
         """
-        images = self.parallax.get_image_index()
-        return images
+        return self.client.get_images()
 
     def detail(self, context):
         """
         Calls out to Parallax for a list of detailed image information
         """
-        images = self.parallax.get_image_details()
-        return images
+        return self.client.get_images_detailed()
 
     def show(self, context, id):
         """
         Returns a dict containing image data for the given opaque image id.
         """
-        image = self.parallax.get_image_metadata(id)
+        image = self.client.get_image_meta(id)
         if image:
             return image
         raise exception.NotFound
@@ -203,7 +66,7 @@ class GlanceImageService(nova.image.service.BaseImageService):
         :raises AlreadyExists if the image already exist.
 
         """
-        return self.parallax.add_image_metadata(data)
+        return self.client.add_image(image_meta=data)
 
     def update(self, context, image_id, data):
         """Replace the contents of the given image with the new data.
@@ -211,7 +74,7 @@ class GlanceImageService(nova.image.service.BaseImageService):
         :raises NotFound if the image does not exist.
 
         """
-        self.parallax.update_image_metadata(image_id, data)
+        return self.client.update_image(image_id, data)
 
     def delete(self, context, image_id):
         """
@@ -220,10 +83,10 @@ class GlanceImageService(nova.image.service.BaseImageService):
         :raises NotFound if the image does not exist.
 
         """
-        self.parallax.delete_image_metadata(image_id)
+        return self.client.delete_image(image_id)
 
     def delete_all(self):
         """
         Clears out all images
         """
-        pass
+        raise NotImplementedError