Cleaned up TODOs, using flags now

3 files changed, 38 insertions, 36 deletions

diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index 1b18b0a01..729f0daaf 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -19,11 +19,12 @@ Helper methods for operations related to the management of VM records and
 their attributes like VDIs, VIFs, as well as their lookup functions.
 """
 
-import time #FIXME(sirp): take this out, replace with greenthread.sleep
 import logging
+import pickle
 import urllib
 from xml.dom import minidom
 
+from eventlet import event
 from nova import flags
 from nova import utils
 from nova.auth.manager import AuthManager
@@ -166,8 +167,6 @@ class VMHelper():
         vdi_rec = session.get_xenapi().VDI.get_record(vdi_ref)
         vdi_uuid = vdi_rec["uuid"]
 
-        #NOTE(sirp): We may need to wait for our parent to coalese with his 
-        # parent
         original_parent_uuid = get_vhd_parent_uuid(session, vdi_ref)
 
         task = session.call_xenapi('Async.VM.snapshot', vm_ref, label)
@@ -186,8 +185,14 @@ class VMHelper():
     def upload_image(cls, session, vdi_uuids, glance_label):
         logging.debug("Asking xapi to upload %s as '%s'", vdi_uuids,
                       glance_label)
-        kwargs = {'vdi_uuids': ','.join(vdi_uuids), 
-                  'glance_label': glance_label}
+
+        params = {'vdi_uuids': vdi_uuids, 
+                  'glance_label': glance_label,
+                  'glance_storage_location': FLAGS.glance_storage_location,
+                  'glance_host': FLAGS.glance_host,
+                  'glance_port': FLAGS.glance_port}
+
+        kwargs = {'params': pickle.dumps(params)}
         task = session.async_call_plugin('glance', 'put_vdis', kwargs)
         session.wait_for_task(task)
 
@@ -341,27 +346,24 @@ def scan_sr(session, sr_ref):
 
 def wait_for_vhd_coalesce(session, sr_ref, vdi_ref, original_parent_uuid):
     """ TODO Explain why coalescing has to occur here """
-    #TODO(sirp): we need to timeout this req after a while
     #NOTE(sirp): for some reason re-scan wasn't occuring automatically on 
     # XS5.6
-    #TODO(sirp): clean this up, perhaps use LoopingCall
-    def _get_vhd_parent_uuid_with_refresh(first_time):
-        if not first_time:
-            #TODO(sirp): should this interval be a gflag?
-            #TODO(sirp): make this non-blocking
-            time.sleep(5)
-        scan_sr(session, sr_ref)
-        return get_vhd_parent_uuid(session, vdi_ref)
-
-    parent_uuid = _get_vhd_parent_uuid_with_refresh(first_time=True)
-    logging.debug(
-        "Parent %s doesn't match original parent %s, "
-        "waiting for coalesce...", parent_uuid, original_parent_uuid)
-    while original_parent_uuid and (parent_uuid != original_parent_uuid):
-        logging.debug(
-            "Parent %s doesn't match original parent %s, "
-            "waiting for coalesce...", parent_uuid, original_parent_uuid)
-        parent_uuid = _get_vhd_parent_uuid_with_refresh(first_time=False)
+    #TODO(sirp): we need to timeout this req after a while
 
+    def _poll_vhds():
+        scan_sr(session, sr_ref)
+        parent_uuid = get_vhd_parent_uuid(session, vdi_ref)
+        if original_parent_uuid and (parent_uuid != original_parent_uuid):
+            logging.debug(
+                "Parent %s doesn't match original parent %s, "
+                "waiting for coalesce...", parent_uuid, original_parent_uuid)
+        else:
+            done.send(parent_uuid)
+ 
+    done = event.Event()
+    loop = utils.LoopingCall(_poll_vhds)
+    loop.start(FLAGS.xenapi_vhd_coalesce_poll_interval, now=True)
+    parent_uuid = done.wait()
+    loop.stop()
     return parent_uuid
 
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 988c54d6d..a44492d57 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -79,29 +79,26 @@ class VMOps(object):
         logging.info('Spawning VM %s created %s.', instance.name,
                      vm_ref)
     
-    def snapshot(self, instance):
+    def snapshot(self, instance, name):
         """ Create snapshot from a running VM instance """
-        logging.debug("Starting snapshot for VM %s", instance)
+
         #TODO(sirp): Add quiesce and VSS locking support when Windows support
         # is added
+
+        logging.debug("Starting snapshot for VM %s", instance)
         vm_ref = VMHelper.lookup(self._session, instance.name)
 
-        #TODO(sirp): this is the label in Xen, we need to add a human friendly
-        # label that we store in paralalx
         label = "%s-snapshot" % instance.name
-        glance_name = "MySnapshot"
-    
         try:
             template_vm_ref, template_vdi_uuids = VMHelper.create_snapshot(
                 self._session, vm_ref, label)
         except XenAPI.Failure, exc:
             logging.error("Unable to Snapshot %s: %s", vm_ref, exc)
             return
-        
+       
         try:
             # call plugin to ship snapshot off to glance
-            VMHelper.upload_image(
-                self._session, template_vdi_uuids, glance_name)
+            VMHelper.upload_image(self._session, template_vdi_uuids, name) 
         finally:
             self._destroy(template_vm_ref, shutdown=False)
 
diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py
index 8aacec507..92e66d32d 100644
--- a/nova/virt/xenapi_conn.py
+++ b/nova/virt/xenapi_conn.py
@@ -77,7 +77,10 @@ flags.DEFINE_float('xenapi_task_poll_interval',
                    'The interval used for polling of remote tasks '
                    '(Async.VM.start, etc).  Used only if '
                    'connection_type=xenapi.')
-
+flags.DEFINE_float('xenapi_vhd_coalesce_poll_interval',
+                   5.0,
+                   'The interval used for polling of coalescing vhds.'
+                   '  Used only if connection_type=xenapi.')
 XenAPI = None
 
 
@@ -116,11 +119,11 @@ class XenAPIConnection(object):
         self._vmops.spawn(instance)
 
 
-    def snapshot(self, instance):
+    def snapshot(self, instance, name):
         """ Create snapshot from a running VM instance """
         #TODO(sirp): Add quiesce and VSS locking support when Windows support
         # is added
-        self._vmops.snapshot(instance)
+        self._vmops.snapshot(instance, name)
 
     def reboot(self, instance):
         """ Reboot VM instance """