xenapi iscsi support + unittests

8 files changed, 937 insertions, 111 deletions

diff --git a/nova/virt/xenapi/__init__.py b/nova/virt/xenapi/__init__.py
index 3d598c463..c75162f08 100644
--- a/nova/virt/xenapi/__init__.py
+++ b/nova/virt/xenapi/__init__.py
@@ -13,3 +13,18 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
+
+"""
+:mod:`xenapi` -- Nova support for XenServer and XCP through XenAPI
+==================================================================
+"""
+
+
+class HelperBase(object):
+    """
+    The base for helper classes. This adds the XenAPI class attribute
+    """
+    XenAPI = None
+
+    def __init__(self):
+        return
diff --git a/nova/virt/xenapi/fake.py b/nova/virt/xenapi/fake.py
new file mode 100644
index 000000000..7a6c9ee71
--- /dev/null
+++ b/nova/virt/xenapi/fake.py
@@ -0,0 +1,388 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+#
+#    Copyright (c) 2010 Citrix Systems, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+#
+#============================================================================
+#
+# Parts of this file are based upon xmlrpclib.py, the XML-RPC client
+# interface included in the Python distribution.
+#
+# Copyright (c) 1999-2002 by Secret Labs AB
+# Copyright (c) 1999-2002 by Fredrik Lundh
+#
+# By obtaining, using, and/or copying this software and/or its
+# associated documentation, you agree that you have read, understood,
+# and will comply with the following terms and conditions:
+#
+# Permission to use, copy, modify, and distribute this software and
+# its associated documentation for any purpose and without fee is
+# hereby granted, provided that the above copyright notice appears in
+# all copies, and that both that copyright notice and this permission
+# notice appear in supporting documentation, and that the name of
+# Secret Labs AB or the author not be used in advertising or publicity
+# pertaining to distribution of the software without specific, written
+# prior permission.
+#
+# SECRET LABS AB AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD
+# TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANT-
+# ABILITY AND FITNESS.  IN NO EVENT SHALL SECRET LABS AB OR THE AUTHOR
+# BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
+# DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
+# ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
+# OF THIS SOFTWARE.
+# --------------------------------------------------------------------
+
+
+"""
+A fake XenAPI SDK.
+"""
+
+
+import datetime
+import logging
+import uuid
+
+from nova import exception
+
+
+_CLASSES = ['host', 'network', 'session', 'SR', 'VBD',\
+            'PBD', 'VDI', 'VIF', 'VM', 'task']
+
+_db_content = {}
+
+
+def reset():
+    for c in _CLASSES:
+        _db_content[c] = {}
+    create_host('fake')
+
+
+def create_host(name_label):
+    return _create_object('host', {
+        'name_label': name_label,
+        })
+
+
+def create_network(name_label, bridge):
+    return _create_object('network', {
+        'name_label': name_label,
+        'bridge': bridge,
+        })
+
+
+def create_vm(name_label, status,
+              is_a_template=False, is_control_domain=False):
+    return _create_object('VM', {
+        'name_label': name_label,
+        'power-state': status,
+        'is_a_template': is_a_template,
+        'is_control_domain': is_control_domain,
+        })
+
+
+def create_vdi(name_label, read_only, sr_ref, sharable):
+    return _create_object('VDI', {
+        'name_label': name_label,
+        'read_only': read_only,
+        'SR': sr_ref,
+        'type': '',
+        'name_description': '',
+        'sharable': sharable,
+        'other_config': {},
+        'location': '',
+        'xenstore_data': '',
+        'sm_config': {},
+        'VBDs': {},
+        })
+
+
+def create_pbd(config, sr_ref, attached):
+    return _create_object('PBD', {
+        'device-config': config,
+        'SR': sr_ref,
+        'currently-attached': attached,
+        })
+
+
+def create_task(name_label):
+    return _create_object('task', {
+        'name_label': name_label,
+        'status': 'pending',
+        })
+
+
+def _create_object(table, obj):
+    ref = str(uuid.uuid4())
+    obj['uuid'] = str(uuid.uuid4())
+    _db_content[table][ref] = obj
+    return ref
+
+
+def _create_sr(table, obj):
+    sr_type = obj[6]
+    # Forces fake to support iscsi only
+    if sr_type != 'iscsi':
+        raise Failure(['SR_UNKNOWN_DRIVER', sr_type])
+    sr_ref = _create_object(table, obj[2])
+    vdi_ref = create_vdi('', False, sr_ref, False)
+    pbd_ref = create_pbd('', sr_ref, True)
+    _db_content['SR'][sr_ref]['VDIs'] = [vdi_ref]
+    _db_content['SR'][sr_ref]['PBDs'] = [pbd_ref]
+    _db_content['VDI'][vdi_ref]['SR'] = sr_ref
+    _db_content['PBD'][pbd_ref]['SR'] = sr_ref
+    return sr_ref
+
+
+def get_all(table):
+    return _db_content[table].keys()
+
+
+def get_all_records(table):
+    return _db_content[table]
+
+
+def get_record(table, ref):
+    if ref in _db_content[table]:
+        return _db_content[table].get(ref)
+    else:
+        raise Failure(['HANDLE_INVALID', table, ref])
+
+
+def check_for_session_leaks():
+    if len(_db_content['session']) > 0:
+        raise exception.Error('Sessions have leaked: %s' %
+                              _db_content['session'])
+
+
+class Failure(Exception):
+    def __init__(self, details):
+        self.details = details
+
+    def __str__(self):
+        try:
+            return str(self.details)
+        except Exception, exc:
+            return "XenAPI Fake Failure: %s" % str(self.details)
+
+    def _details_map(self):
+        return dict([(str(i), self.details[i])
+                     for i in range(len(self.details))])
+
+
+class SessionBase(object):
+    """
+    Base class for Fake Sessions
+    """
+
+    def __init__(self, uri):
+        self._session = None
+
+    def xenapi_request(self, methodname, params):
+        if methodname.startswith('login'):
+            self._login(methodname, params)
+            return None
+        elif methodname == 'logout' or methodname == 'session.logout':
+            self._logout()
+            return None
+        else:
+            full_params = (self._session,) + params
+            meth = getattr(self, methodname, None)
+            if meth is None:
+                logging.warn('Raising NotImplemented')
+                raise NotImplementedError(
+                    'xenapi.fake does not have an implementation for %s' %
+                    methodname)
+            return meth(*full_params)
+
+    def _login(self, method, params):
+        self._session = str(uuid.uuid4())
+        _db_content['session'][self._session] = {
+            'uuid': str(uuid.uuid4()),
+            'this_host': _db_content['host'].keys()[0],
+            }
+
+    def _logout(self):
+        s = self._session
+        self._session = None
+        if s not in _db_content['session']:
+            raise exception.Error(
+                "Logging out a session that is invalid or already logged "
+                "out: %s" % s)
+        del _db_content['session'][s]
+
+    def __getattr__(self, name):
+        if name == 'handle':
+            return self._session
+        elif name == 'xenapi':
+            return _Dispatcher(self.xenapi_request, None)
+        elif name.startswith('login') or name.startswith('slave_local'):
+            return lambda *params: self._login(name, params)
+        elif name.startswith('Async'):
+            return lambda *params: self._async(name, params)
+        elif '.' in name:
+            impl = getattr(self, name.replace('.', '_'))
+            if impl is not None:
+                def callit(*params):
+                    logging.warn('Calling %s %s', name, impl)
+                    self._check_session(params)
+                    return impl(*params)
+                return callit
+        if self._is_gettersetter(name, True):
+            logging.warn('Calling getter %s', name)
+            return lambda *params: self._getter(name, params)
+        elif self._is_create(name):
+            return lambda *params: self._create(name, params)
+        else:
+            return None
+
+    def _is_gettersetter(self, name, getter):
+        bits = name.split('.')
+        return (len(bits) == 2 and
+                bits[0] in _CLASSES and
+                bits[1].startswith(getter and 'get_' or 'set_'))
+
+    def _is_create(self, name):
+        bits = name.split('.')
+        return (len(bits) == 2 and
+                bits[0] in _CLASSES and
+                bits[1] == 'create')
+
+    def _getter(self, name, params):
+        self._check_session(params)
+        (cls, func) = name.split('.')
+
+        if func == 'get_all':
+            self._check_arg_count(params, 1)
+            return get_all(cls)
+
+        if func == 'get_all_records':
+            self._check_arg_count(params, 1)
+            return get_all_records(cls)
+
+        if func == 'get_record':
+            self._check_arg_count(params, 2)
+            return get_record(cls, params[1])
+
+        if (func == 'get_by_name_label' or
+            func == 'get_by_uuid'):
+            self._check_arg_count(params, 2)
+            return self._get_by_field(
+                _db_content[cls], func[len('get_by_'):], params[1])
+
+        if len(params) == 2:
+            field = func[len('get_'):]
+            ref = params[1]
+
+            if (ref in _db_content[cls] and
+                field in _db_content[cls][ref]):
+                return _db_content[cls][ref][field]
+
+        logging.error('Raising NotImplemented')
+        raise NotImplementedError(
+            'xenapi.fake does not have an implementation for %s or it has '
+            'been called with the wrong number of arguments' % name)
+
+    def _setter(self, name, params):
+        self._check_session(params)
+        (cls, func) = name.split('.')
+
+        if len(params) == 3:
+            field = func[len('set_'):]
+            ref = params[1]
+            val = params[2]
+
+            if (ref in _db_content[cls] and
+                field in _db_content[cls][ref]):
+                _db_content[cls][ref][field] = val
+
+        logging.warn('Raising NotImplemented')
+        raise NotImplementedError(
+            'xenapi.fake does not have an implementation for %s or it has '
+            'been called with the wrong number of arguments or the database '
+            'is missing that field' % name)
+
+    def _create(self, name, params):
+        self._check_session(params)
+        is_sr_create = name == 'SR.create'
+        # Storage Repositories have a different API
+        expected = is_sr_create and 10 or 2
+        self._check_arg_count(params, expected)
+        (cls, _) = name.split('.')
+        ref = is_sr_create and \
+            _create_sr(cls, params) or _create_object(cls, params[1])
+        obj = get_record(cls, ref)
+
+        # Add RO fields
+        if cls == 'VM':
+            obj['power_state'] = 'Halted'
+
+        return ref
+
+    def _async(self, name, params):
+        task_ref = create_task(name)
+        task = _db_content['task'][task_ref]
+        func = name[len('Async.'):]
+        try:
+            task['result'] = self.xenapi_request(func, params[1:])
+            task['status'] = 'success'
+        except Failure, exc:
+            task['error_info'] = exc.details
+            task['status'] = 'failed'
+        task['finished'] = datetime.datetime.now()
+        return task_ref
+
+    def _check_session(self, params):
+        if (self._session is None or
+            self._session not in _db_content['session']):
+            raise Failure(['HANDLE_INVALID', 'session', self._session])
+        if len(params) == 0 or params[0] != self._session:
+            logging.warn('Raising NotImplemented')
+            raise NotImplementedError('Call to XenAPI without using .xenapi')
+
+    def _check_arg_count(self, params, expected):
+        actual = len(params)
+        if actual != expected:
+            raise Failure(['MESSAGE_PARAMETER_COUNT_MISMATCH',
+                                  expected, actual])
+
+    def _get_by_field(self, recs, k, v):
+        result = []
+        for ref, rec in recs.iteritems():
+            if rec.get(k) == v:
+                result.append(ref)
+        return result
+
+
+# Based upon _Method from xmlrpclib.
+class _Dispatcher:
+    def __init__(self, send, name):
+        self.__send = send
+        self.__name = name
+
+    def __repr__(self):
+        if self.__name:
+            return '<xenapi.fake._Dispatcher for %s>' % self.__name
+        else:
+            return '<xenapi.fake._Dispatcher>'
+
+    def __getattr__(self, name):
+        if self.__name is None:
+            return _Dispatcher(self.__send, name)
+        else:
+            return _Dispatcher(self.__send, "%s.%s" % (self.__name, name))
+
+    def __call__(self, *args):
+        return self.__send(self.__name, args)
diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py
index ce2c68ce0..c0406d8f0 100644
--- a/nova/virt/xenapi/network_utils.py
+++ b/nova/virt/xenapi/network_utils.py
@@ -21,22 +21,23 @@ their lookup functions.
 """
 
 
-class NetworkHelper():
+from nova.virt.xenapi import HelperBase
+
+
+class NetworkHelper(HelperBase):
     """
     The class that wraps the helper methods together.
     """
 
-    def __init__(self):
-        return
-
     @classmethod
     def find_network_with_bridge(cls, session, bridge):
-        """ Return the network on which the bridge is attached, if found."""
+        """Return the network on which the bridge is attached, if found."""
         expr = 'field "bridge" = "%s"' % bridge
         networks = session.call_xenapi('network.get_all_records_where', expr)
         if len(networks) == 1:
             return networks.keys()[0]
         elif len(networks) > 1:
-            raise Exception('Found non-unique network for bridge %s' % bridge)
+            raise Exception(_('Found non-unique network'
+                              ' for bridge %s') % bridge)
         else:
-            raise Exception('Found no network for bridge %s' % bridge)
+            raise Exception(_('Found no network for bridge %s') % bridge)
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index badaaedc1..89e02c917 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -23,12 +23,14 @@ import logging
 import urllib
 from xml.dom import minidom
 
+from nova import exception
 from nova import flags
-from nova import utils
 from nova.auth.manager import AuthManager
 from nova.compute import instance_types
 from nova.compute import power_state
 from nova.virt import images
+from nova.virt.xenapi import HelperBase
+from nova.virt.xenapi.volume_utils import StorageError
 
 
 FLAGS = flags.FLAGS
@@ -40,33 +42,16 @@ XENAPI_POWER_STATE = {
     'Suspended': power_state.SHUTDOWN,  # FIXME
     'Crashed': power_state.CRASHED}
 
-XenAPI = None
 
-
-class VMHelper():
+class VMHelper(HelperBase):
     """
     The class that wraps the helper methods together.
     """
 
-    def __init__(self):
-        return
-
-    @classmethod
-    def late_import(cls):
-        """
-        Load the XenAPI module in for helper class, if required.
-        This is to avoid to install the XenAPI library when other
-        hypervisors are used
-        """
-        global XenAPI
-        if XenAPI is None:
-            XenAPI = __import__('XenAPI')
-
     @classmethod
     def create_vm(cls, session, instance, kernel, ramdisk):
         """Create a VM record.  Returns a Deferred that gives the new
         VM reference."""
-
         instance_type = instance_types.INSTANCE_TYPES[instance.instance_type]
         mem = str(long(instance_type['memory_mb']) * 1024 * 1024)
         vcpus = str(instance_type['vcpus'])
@@ -99,16 +84,15 @@ class VMHelper():
             'user_version': '0',
             'other_config': {},
             }
-        logging.debug('Created VM %s...', instance.name)
+        logging.debug(_('Created VM %s...'), instance.name)
         vm_ref = session.call_xenapi('VM.create', rec)
-        logging.debug('Created VM %s as %s.', instance.name, vm_ref)
+        logging.debug(_('Created VM %s as %s.'), instance.name, vm_ref)
         return vm_ref
 
     @classmethod
     def create_vbd(cls, session, vm_ref, vdi_ref, userdevice, bootable):
         """Create a VBD record.  Returns a Deferred that gives the new
         VBD reference."""
-
         vbd_rec = {}
         vbd_rec['VM'] = vm_ref
         vbd_rec['VDI'] = vdi_ref
@@ -122,17 +106,53 @@ class VMHelper():
         vbd_rec['qos_algorithm_type'] = ''
         vbd_rec['qos_algorithm_params'] = {}
         vbd_rec['qos_supported_algorithms'] = []
-        logging.debug('Creating VBD for VM %s, VDI %s ... ', vm_ref, vdi_ref)
+        logging.debug(_('Creating VBD for VM %s, VDI %s ... '),
+                      vm_ref, vdi_ref)
         vbd_ref = session.call_xenapi('VBD.create', vbd_rec)
-        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
+        logging.debug(_('Created VBD %s for VM %s, VDI %s.'), vbd_ref, vm_ref,
                       vdi_ref)
         return vbd_ref
 
     @classmethod
+    def find_vbd_by_number(cls, session, vm_ref, number):
+        """Get the VBD reference from the device number"""
+        vbds = session.get_xenapi().VM.get_VBDs(vm_ref)
+        if vbds:
+            for vbd in vbds:
+                try:
+                    vbd_rec = session.get_xenapi().VBD.get_record(vbd)
+                    if vbd_rec['userdevice'] == str(number):
+                        return vbd
+                except cls.XenAPI.Failure, exc:
+                    logging.warn(exc)
+        raise StorageError(_('VBD not found in instance %s') % vm_ref)
+
+    @classmethod
+    def unplug_vbd(cls, session, vbd_ref):
+        """Unplug VBD from VM"""
+        try:
+            vbd_ref = session.call_xenapi('VBD.unplug', vbd_ref)
+        except cls.XenAPI.Failure, exc:
+            logging.warn(exc)
+            if exc.details[0] != 'DEVICE_ALREADY_DETACHED':
+                raise StorageError(_('Unable to unplug VBD %s') % vbd_ref)
+
+    @classmethod
+    def destroy_vbd(cls, session, vbd_ref):
+        """Destroy VBD from host database"""
+        try:
+            task = session.call_xenapi('Async.VBD.destroy', vbd_ref)
+            #FIXME(armando): find a solution to missing instance_id
+            #with Josh Kearney
+            session.wait_for_task(0, task)
+        except cls.XenAPI.Failure, exc:
+            logging.warn(exc)
+            raise StorageError(_('Unable to destroy VBD %s') % vbd_ref)
+
+    @classmethod
     def create_vif(cls, session, vm_ref, network_ref, mac_address):
         """Create a VIF record.  Returns a Deferred that gives the new
         VIF reference."""
-
         vif_rec = {}
         vif_rec['device'] = '0'
         vif_rec['network'] = network_ref
@@ -142,10 +162,10 @@ class VMHelper():
         vif_rec['other_config'] = {}
         vif_rec['qos_algorithm_type'] = ''
         vif_rec['qos_algorithm_params'] = {}
-        logging.debug('Creating VIF for VM %s, network %s ... ', vm_ref,
+        logging.debug(_('Creating VIF for VM %s, network %s.'), vm_ref,
                       network_ref)
         vif_ref = session.call_xenapi('VIF.create', vif_rec)
-        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
+        logging.debug(_('Created VIF %s for VM %s, network %s.'), vif_ref,
                       vm_ref, network_ref)
         return vif_ref
 
@@ -158,7 +178,7 @@ class VMHelper():
 
         url = images.image_url(image)
         access = AuthManager().get_access_key(user, project)
-        logging.debug("Asking xapi to fetch %s as %s", url, access)
+        logging.debug(_("Asking xapi to fetch %s as %s"), url, access)
         fn = use_sr and 'get_vdi' or 'get_kernel'
         args = {}
         args['src_url'] = url
@@ -167,34 +187,26 @@ class VMHelper():
         if use_sr:
             args['add_partition'] = 'true'
         task = session.async_call_plugin('objectstore', fn, args)
-        uuid = session.wait_for_task(task)
+        #FIXME(armando): find a solution to missing instance_id
+        #with Josh Kearney
+        uuid = session.wait_for_task(0, task)
         return uuid
 
     @classmethod
     def lookup(cls, session, i):
-        """ Look the instance i up, and returns it if available """
-        return VMHelper.lookup_blocking(session, i)
-
-    @classmethod
-    def lookup_blocking(cls, session, i):
-        """ Synchronous lookup """
+        """Look the instance i up, and returns it if available"""
         vms = session.get_xenapi().VM.get_by_name_label(i)
         n = len(vms)
         if n == 0:
             return None
         elif n > 1:
-            raise Exception('duplicate name found: %s' % i)
+            raise exception.Duplicate(_('duplicate name found: %s') % i)
         else:
             return vms[0]
 
     @classmethod
     def lookup_vm_vdis(cls, session, vm):
-        """ Look for the VDIs that are attached to the VM """
-        return VMHelper.lookup_vm_vdis_blocking(session, vm)
-
-    @classmethod
-    def lookup_vm_vdis_blocking(cls, session, vm):
-        """ Synchronous lookup_vm_vdis """
+        """Look for the VDIs that are attached to the VM"""
         # Firstly we get the VBDs, then the VDIs.
         # TODO(Armando): do we leave the read-only devices?
         vbds = session.get_xenapi().VM.get_VBDs(vm)
@@ -205,8 +217,9 @@ class VMHelper():
                     vdi = session.get_xenapi().VBD.get_VDI(vbd)
                     # Test valid VDI
                     record = session.get_xenapi().VDI.get_record(vdi)
-                    logging.debug('VDI %s is still available', record['uuid'])
-                except XenAPI.Failure, exc:
+                    logging.debug(_('VDI %s is still available'),
+                                  record['uuid'])
+                except cls.XenAPI.Failure, exc:
                     logging.warn(exc)
                 else:
                     vdis.append(vdi)
@@ -217,6 +230,7 @@ class VMHelper():
 
     @classmethod
     def compile_info(cls, record):
+        """Fill record with VM status information"""
         return {'state': XENAPI_POWER_STATE[record['power_state']],
                 'max_mem': long(record['memory_static_max']) >> 10,
                 'mem': long(record['memory_dynamic_max']) >> 10,
@@ -240,7 +254,7 @@ class VMHelper():
                         # Name and Value
                         diags[ref[0].firstChild.data] = ref[6].firstChild.data
             return diags
-        except XenAPI.Failure as e:
+        except cls.XenAPI.Failure as e:
             return {"Unable to retrieve diagnostics": e}
 
 
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 4d897af35..39bb0f1e8 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -22,13 +22,14 @@ import logging
 
 from nova import db
 from nova import context
+from nova import exception
+from nova import utils
 
 from nova.auth.manager import AuthManager
+from nova.compute import power_state
 from nova.virt.xenapi.network_utils import NetworkHelper
 from nova.virt.xenapi.vm_utils import VMHelper
 
-XenAPI = None
-
 
 class VMOps(object):
     """
@@ -36,12 +37,9 @@ class VMOps(object):
     """
 
     def __init__(self, session):
-        global XenAPI
-        if XenAPI is None:
-            XenAPI = __import__('XenAPI')
+        self.XenAPI = session.get_imported_xenapi()
         self._session = session
-        # Load XenAPI module in the helper class
-        VMHelper.late_import()
+        VMHelper.XenAPI = self.XenAPI
 
     def list_instances(self):
         """List VM instances"""
@@ -56,8 +54,8 @@ class VMOps(object):
         """Create VM instance"""
         vm = VMHelper.lookup(self._session, instance.name)
         if vm is not None:
-            raise Exception('Attempted to create non-unique name %s' %
-                            instance.name)
+            raise exception.Duplicate(_('Attempted to create'
+            ' non-unique name %s') % instance.name)
 
         bridge = db.network_get_by_instance(context.get_admin_context(),
                                             instance['id'])['bridge']
@@ -79,17 +77,41 @@ class VMOps(object):
         if network_ref:
             VMHelper.create_vif(self._session, vm_ref,
                                 network_ref, instance.mac_address)
-        logging.debug('Starting VM %s...', vm_ref)
+        logging.debug(_('Starting VM %s...'), vm_ref)
         self._session.call_xenapi('VM.start', vm_ref, False, False)
-        logging.info('Spawning VM %s created %s.', instance.name,
+        logging.info(_('Spawning VM %s created %s.'), instance.name,
                      vm_ref)
 
+        # NOTE(armando): Do we really need to do this in virt?
+        timer = utils.LoopingCall(f=None)
+
+        def _wait_for_boot():
+            try:
+                state = self.get_info(instance['name'])['state']
+                db.instance_set_state(context.get_admin_context(),
+                                      instance['id'], state)
+                if state == power_state.RUNNING:
+                    logging.debug(_('Instance %s: booted'), instance['name'])
+                    timer.stop()
+            except Exception, exc:
+                logging.warn(exc)
+                logging.exception(_('instance %s: failed to boot'),
+                                  instance['name'])
+                db.instance_set_state(context.get_admin_context(),
+                                      instance['id'],
+                                      power_state.SHUTDOWN)
+                timer.stop()
+
+        timer.f = _wait_for_boot
+        return timer.start(interval=0.5, now=True)
+
     def reboot(self, instance):
         """Reboot VM instance"""
         instance_name = instance.name
         vm = VMHelper.lookup(self._session, instance_name)
         if vm is None:
-            raise Exception('instance not present %s' % instance_name)
+            raise exception.NotFound(_('instance not'
+                                       ' found %s') % instance_name)
         task = self._session.call_xenapi('Async.VM.clean_reboot', vm)
         self._session.wait_for_task(instance.id, task)
 
@@ -116,6 +138,7 @@ class VMOps(object):
                     self._session.wait_for_task(instance.id, task)
                 except XenAPI.Failure, exc:
                     logging.warn(exc)
+        # VM Destroy
         try:
             task = self._session.call_xenapi('Async.VM.destroy', vm)
             self._session.wait_for_task(instance.id, task)
@@ -135,7 +158,8 @@ class VMOps(object):
         instance_name = instance.name
         vm = VMHelper.lookup(self._session, instance_name)
         if vm is None:
-            raise Exception('instance not present %s' % instance_name)
+            raise exception.NotFound(_('Instance not'
+                                       ' found %s') % instance_name)
         task = self._session.call_xenapi('Async.VM.pause', vm)
         self._wait_with_callback(instance.id, task, callback)
 
@@ -144,15 +168,17 @@ class VMOps(object):
         instance_name = instance.name
         vm = VMHelper.lookup(self._session, instance_name)
         if vm is None:
-            raise Exception('instance not present %s' % instance_name)
+            raise exception.NotFound(_('Instance not'
+                                       ' found %s') % instance_name)
         task = self._session.call_xenapi('Async.VM.unpause', vm)
         self._wait_with_callback(instance.id, task, callback)
 
     def get_info(self, instance_id):
         """Return data about VM instance"""
-        vm = VMHelper.lookup_blocking(self._session, instance_id)
+        vm = VMHelper.lookup(self._session, instance_id)
         if vm is None:
-            raise Exception('instance not present %s' % instance_id)
+            raise exception.NotFound(_('Instance not'
+                                       ' found %s') % instance_id)
         rec = self._session.get_xenapi().VM.get_record(vm)
         return VMHelper.compile_info(rec)
 
@@ -160,7 +186,7 @@ class VMOps(object):
         """Return data about VM diagnostics"""
         vm = VMHelper.lookup(self._session, instance_id)
         if vm is None:
-            raise Exception("instance not present %s" % instance_id)
+            raise exception.NotFound(_("Instance not found %s") % instance_id)
         rec = self._session.get_xenapi().VM.get_record(vm)
         return VMHelper.compile_diagnostics(self._session, rec)
 
diff --git a/nova/virt/xenapi/volume_utils.py b/nova/virt/xenapi/volume_utils.py
new file mode 100644
index 000000000..a0c0a67d4
--- /dev/null
+++ b/nova/virt/xenapi/volume_utils.py
@@ -0,0 +1,268 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2010 Citrix Systems, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Helper methods for operations related to the management of volumes,
+and storage repositories
+"""
+
+import re
+import string
+import logging
+
+from nova import db
+from nova import context
+from nova import exception
+from nova import flags
+from nova import utils
+from nova.virt.xenapi import HelperBase
+
+FLAGS = flags.FLAGS
+
+
+class StorageError(Exception):
+    """To raise errors related to SR, VDI, PBD, and VBD commands"""
+
+    def __init__(self, message=None):
+        super(StorageError, self).__init__(message)
+
+
+class VolumeHelper(HelperBase):
+    """
+    The class that wraps the helper methods together.
+    """
+
+    @classmethod
+    def create_iscsi_storage(cls, session, info, label, description):
+        """
+        Create an iSCSI storage repository that will be used to mount
+        the volume for the specified instance
+        """
+        sr_ref = session.get_xenapi().SR.get_by_name_label(label)
+        if len(sr_ref) == 0:
+            logging.debug('Introducing %s...', label)
+            record = {}
+            if 'chapuser' in info and 'chappassword' in info:
+                record = {'target': info['targetHost'],
+                          'port': info['targetPort'],
+                          'targetIQN': info['targetIQN'],
+                          'chapuser': info['chapuser'],
+                          'chappassword': info['chappassword']
+                          }
+            else:
+                record = {'target': info['targetHost'],
+                          'port': info['targetPort'],
+                          'targetIQN': info['targetIQN']
+                          }
+            try:
+                sr_ref = session.get_xenapi().SR.create(
+                    session.get_xenapi_host(),
+                    record,
+                    '0', label, description, 'iscsi', '', False, {})
+                logging.debug('Introduced %s as %s.', label, sr_ref)
+                return sr_ref
+            except cls.XenAPI.Failure, exc:
+                logging.warn(exc)
+                raise StorageError(_('Unable to create Storage Repository'))
+        else:
+            return sr_ref[0]
+
+    @classmethod
+    def find_sr_from_vbd(cls, session, vbd_ref):
+        """Find the SR reference from the VBD reference"""
+        try:
+            vdi_ref = session.get_xenapi().VBD.get_VDI(vbd_ref)
+            sr_ref = session.get_xenapi().VDI.get_SR(vdi_ref)
+        except cls.XenAPI.Failure, exc:
+            logging.warn(exc)
+            raise StorageError(_('Unable to find SR from VBD %s') % vbd_ref)
+        return sr_ref
+
+    @classmethod
+    def destroy_iscsi_storage(cls, session, sr_ref):
+        """Forget the SR whilst preserving the state of the disk"""
+        logging.debug("Forgetting SR %s ... ", sr_ref)
+        pbds = []
+        try:
+            pbds = session.get_xenapi().SR.get_PBDs(sr_ref)
+        except cls.XenAPI.Failure, exc:
+            logging.warn('Ignoring exception %s when getting PBDs for %s',
+                         exc, sr_ref)
+        for pbd in pbds:
+            try:
+                session.get_xenapi().PBD.unplug(pbd)
+            except cls.XenAPI.Failure, exc:
+                logging.warn('Ignoring exception %s when unplugging PBD %s',
+                             exc, pbd)
+        try:
+            session.get_xenapi().SR.forget(sr_ref)
+            logging.debug("Forgetting SR %s done.", sr_ref)
+        except cls.XenAPI.Failure, exc:
+            logging.warn('Ignoring exception %s when forgetting SR %s',
+                         exc, sr_ref)
+
+    @classmethod
+    def introduce_vdi(cls, session, sr_ref):
+        """Introduce VDI in the host"""
+        try:
+            vdis = session.get_xenapi().SR.get_VDIs(sr_ref)
+        except cls.XenAPI.Failure, exc:
+            logging.warn(exc)
+            raise StorageError(_('Unable to introduce VDI on SR %s') % sr_ref)
+        try:
+            vdi_rec = session.get_xenapi().VDI.get_record(vdis[0])
+        except cls.XenAPI.Failure, exc:
+            logging.warn(exc)
+            raise StorageError(_('Unable to get record'
+                                 ' of VDI %s on') % vdis[0])
+        else:
+            try:
+                return session.get_xenapi().VDI.introduce(
+                    vdi_rec['uuid'],
+                    vdi_rec['name_label'],
+                    vdi_rec['name_description'],
+                    vdi_rec['SR'],
+                    vdi_rec['type'],
+                    vdi_rec['sharable'],
+                    vdi_rec['read_only'],
+                    vdi_rec['other_config'],
+                    vdi_rec['location'],
+                    vdi_rec['xenstore_data'],
+                    vdi_rec['sm_config'])
+            except cls.XenAPI.Failure, exc:
+                logging.warn(exc)
+                raise StorageError(_('Unable to introduce VDI for SR %s')
+                                   % sr_ref)
+
+    @classmethod
+    def parse_volume_info(cls, device_path, mountpoint):
+        """
+        Parse device_path and mountpoint as they can be used by XenAPI.
+        In particular, the mountpoint (e.g. /dev/sdc) must be translated
+        into a numeric literal.
+        FIXME(armando):
+        As for device_path, currently cannot be used as it is,
+        because it does not contain target information. As for interim
+        solution, target details are passed either via Flags or obtained
+        by iscsiadm. Long-term solution is to add a few more fields to the
+        db in the iscsi_target table with the necessary info and modify
+        the iscsi driver to set them.
+        """
+        device_number = VolumeHelper.mountpoint_to_number(mountpoint)
+        volume_id = _get_volume_id(device_path)
+        (iscsi_name, iscsi_portal) = _get_target(volume_id)
+        target_host = _get_target_host(iscsi_portal)
+        target_port = _get_target_port(iscsi_portal)
+        target_iqn = _get_iqn(iscsi_name, volume_id)
+        logging.debug('(vol_id,number,host,port,iqn): (%s,%s,%s,%s)',
+                      volume_id,
+                      target_host,
+                      target_port,
+                      target_iqn)
+        if (device_number < 0) or \
+            (volume_id is None) or \
+            (target_host is None) or \
+            (target_iqn is None):
+            raise StorageError(_('Unable to obtain target information %s, %s')
+                               % (device_path, mountpoint))
+        volume_info = {}
+        volume_info['deviceNumber'] = device_number
+        volume_info['volumeId'] = volume_id
+        volume_info['targetHost'] = target_host
+        volume_info['targetPort'] = target_port
+        volume_info['targetIQN'] = target_iqn
+        return volume_info
+
+    @classmethod
+    def mountpoint_to_number(cls, mountpoint):
+        """Translate a mountpoint like /dev/sdc into a numeric"""
+        if mountpoint.startswith('/dev/'):
+            mountpoint = mountpoint[5:]
+        if re.match('^[hs]d[a-p]$', mountpoint):
+            return (ord(mountpoint[2:3]) - ord('a'))
+        elif re.match('^vd[a-p]$', mountpoint):
+            return (ord(mountpoint[2:3]) - ord('a'))
+        elif re.match('^[0-9]+$', mountpoint):
+            return string.atoi(mountpoint, 10)
+        else:
+            logging.warn('Mountpoint cannot be translated: %s', mountpoint)
+            return -1
+
+
+def _get_volume_id(path):
+    """Retrieve the volume id from device_path"""
+    # n must contain at least the volume_id
+    # /vol- is for remote volumes
+    # -vol- is for local volumes
+    # see compute/manager->setup_compute_volume
+    volume_id = path[path.find('/vol-') + 1:]
+    if volume_id == path:
+        volume_id = path[path.find('-vol-') + 1:].replace('--', '-')
+    return volume_id
+
+
+def _get_target_host(iscsi_string):
+    """Retrieve target host"""
+    if iscsi_string:
+        return iscsi_string[0:iscsi_string.find(':')]
+    elif iscsi_string is None or FLAGS.target_host:
+        return FLAGS.target_host
+
+
+def _get_target_port(iscsi_string):
+    """Retrieve target port"""
+    if iscsi_string:
+        return iscsi_string[iscsi_string.find(':') + 1:]
+    elif  iscsi_string is None or FLAGS.target_port:
+        return FLAGS.target_port
+
+
+def _get_iqn(iscsi_string, id):
+    """Retrieve target IQN"""
+    if iscsi_string:
+        return iscsi_string
+    elif iscsi_string is None or FLAGS.iqn_prefix:
+        volume_id = _get_volume_id(id)
+        return '%s:%s' % (FLAGS.iqn_prefix, volume_id)
+
+
+def _get_target(volume_id):
+    """
+    Gets iscsi name and portal from volume name and host.
+    For this method to work the following are needed:
+    1) volume_ref['host'] must resolve to something rather than loopback
+    2) ietd must bind only to the address as resolved above
+    If any of the two conditions are not met, fall back on Flags.
+    """
+    volume_ref = db.volume_get_by_ec2_id(context.get_admin_context(),
+                                         volume_id)
+    result = (None, None)
+    try:
+        (r, _e) = utils.execute("sudo iscsiadm -m discovery -t "
+                                     "sendtargets -p %s" %
+                                     volume_ref['host'])
+    except exception.ProcessExecutionError, exc:
+        logging.warn(exc)
+    else:
+        targets = r.splitlines()
+        if len(_e) == 0 and len(targets) == 1:
+            for target in targets:
+                if volume_id in target:
+                    (location, _sep, iscsi_name) = target.partition(" ")
+                    break
+            iscsi_portal = location.split(",")[0]
+            result = (iscsi_name, iscsi_portal)
+    return result
diff --git a/nova/virt/xenapi/volumeops.py b/nova/virt/xenapi/volumeops.py
index 1943ccab0..fdeb2506c 100644
--- a/nova/virt/xenapi/volumeops.py
+++ b/nova/virt/xenapi/volumeops.py
@@ -17,17 +17,110 @@
 """
 Management class for Storage-related functions (attach, detach, etc).
 """
+import logging
+
+from nova import exception
+from nova.virt.xenapi.vm_utils import VMHelper
+from nova.virt.xenapi.volume_utils import VolumeHelper
+from nova.virt.xenapi.volume_utils import StorageError
 
 
 class VolumeOps(object):
+    """
+    Management class for Volume-related tasks
+    """
 
     def __init__(self, session):
+        self.XenAPI = session.get_imported_xenapi()
         self._session = session
+        # Load XenAPI module in the helper classes respectively
+        VolumeHelper.XenAPI = self.XenAPI
+        VMHelper.XenAPI = self.XenAPI
 
     def attach_volume(self, instance_name, device_path, mountpoint):
-        # FIXME: that's going to be sorted when iscsi-xenapi lands in branch
-        return True
+        """Attach volume storage to VM instance"""
+        # Before we start, check that the VM exists
+        vm_ref = VMHelper.lookup(self._session, instance_name)
+        if vm_ref is None:
+            raise exception.NotFound(_('Instance %s not found')
+                                      % instance_name)
+        # NOTE: No Resource Pool concept so far
+        logging.debug(_("Attach_volume: %s, %s, %s"),
+                      instance_name, device_path, mountpoint)
+        # Create the iSCSI SR, and the PDB through which hosts access SRs.
+        # But first, retrieve target info, like Host, IQN, LUN and SCSIID
+        vol_rec = VolumeHelper.parse_volume_info(device_path, mountpoint)
+        label = 'SR-%s' % vol_rec['volumeId']
+        description = 'Disk-for:%s' % instance_name
+        # Create SR
+        sr_ref = VolumeHelper.create_iscsi_storage(self._session,
+                                                         vol_rec,
+                                                         label,
+                                                         description)
+        # Introduce VDI  and attach VBD to VM
+        try:
+            vdi_ref = VolumeHelper.introduce_vdi(self._session, sr_ref)
+        except StorageError, exc:
+            logging.warn(exc)
+            VolumeHelper.destroy_iscsi_storage(self._session, sr_ref)
+            raise Exception(_('Unable to create VDI on SR %s for instance %s')
+                            % (sr_ref,
+                            instance_name))
+        else:
+            try:
+                vbd_ref = VMHelper.create_vbd(self._session,
+                                                    vm_ref, vdi_ref,
+                                                    vol_rec['deviceNumber'],
+                                                    False)
+            except self.XenAPI.Failure, exc:
+                logging.warn(exc)
+                VolumeHelper.destroy_iscsi_storage(self._session, sr_ref)
+                raise Exception(_('Unable to use SR %s for instance %s')
+                            % (sr_ref,
+                            instance_name))
+            else:
+                try:
+                    task = self._session.call_xenapi('Async.VBD.plug',
+                                                           vbd_ref)
+                    self._session.wait_for_task(vol_rec['deviceNumber'], task)
+                except self.XenAPI.Failure, exc:
+                    logging.warn(exc)
+                    VolumeHelper.destroy_iscsi_storage(self._session,
+                                                             sr_ref)
+                    raise Exception(_('Unable to attach volume to instance %s')
+                                    % instance_name)
+        logging.info(_('Mountpoint %s attached to instance %s'),
+                     mountpoint, instance_name)
 
     def detach_volume(self, instance_name, mountpoint):
-        # FIXME: that's going to be sorted when iscsi-xenapi lands in branch
-        return True
+        """Detach volume storage to VM instance"""
+        # Before we start, check that the VM exists
+        vm_ref = VMHelper.lookup(self._session, instance_name)
+        if vm_ref is None:
+            raise exception.NotFound(_('Instance %s not found')
+                                     % instance_name)
+        # Detach VBD from VM
+        logging.debug(_("Detach_volume: %s, %s"), instance_name, mountpoint)
+        device_number = VolumeHelper.mountpoint_to_number(mountpoint)
+        try:
+            vbd_ref = VMHelper.find_vbd_by_number(self._session,
+                                                        vm_ref, device_number)
+        except StorageError, exc:
+            logging.warn(exc)
+            raise Exception(_('Unable to locate volume %s') % mountpoint)
+        else:
+            try:
+                sr_ref = VolumeHelper.find_sr_from_vbd(self._session,
+                                                             vbd_ref)
+                VMHelper.unplug_vbd(self._session, vbd_ref)
+            except StorageError, exc:
+                logging.warn(exc)
+                raise Exception(_('Unable to detach volume %s') % mountpoint)
+            try:
+                VMHelper.destroy_vbd(self._session, vbd_ref)
+            except StorageError, exc:
+                logging.warn(exc)
+        # Forget SR
+        VolumeHelper.destroy_iscsi_storage(self._session, sr_ref)
+        logging.info(_('Mountpoint %s detached from instance %s'),
+                     mountpoint, instance_name)
diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py
index 146e2f153..11c66c974 100644
--- a/nova/virt/xenapi_conn.py
+++ b/nova/virt/xenapi_conn.py
@@ -44,7 +44,10 @@ reactor thread if the VM.get_by_name_label or VM.get_record calls block.
 :xenapi_task_poll_interval:  The interval (seconds) used for polling of
                              remote tasks (Async.VM.start, etc)
                              (default: 0.5).
-
+:target_host:                the iSCSI Target Host IP address, i.e. the IP
+                             address for the nova-volume host
+:target_port:                iSCSI Target Port, 3260 Default
+:iqn_prefix:                 IQN Prefix, e.g. 'iqn.2010-10.org.openstack'
 """
 
 import logging
@@ -62,6 +65,7 @@ from nova.virt.xenapi.vmops import VMOps
 from nova.virt.xenapi.volumeops import VolumeOps
 
 FLAGS = flags.FLAGS
+
 flags.DEFINE_string('xenapi_connection_url',
                     None,
                     'URL for connection to XenServer/Xen Cloud Platform.'
@@ -79,18 +83,20 @@ 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.')
-
-XenAPI = None
+flags.DEFINE_string('target_host',
+                    None,
+                    'iSCSI Target Host')
+flags.DEFINE_string('target_port',
+                    '3260',
+                    'iSCSI Target Port, 3260 Default')
+flags.DEFINE_string('iqn_prefix',
+                    'iqn.2010-10.org.openstack',
+                    'IQN Prefix')
 
 
 def get_connection(_):
     """Note that XenAPI doesn't have a read-only connection mode, so
     the read_only parameter is ignored."""
-    # This is loaded late so that there's no need to install this
-    # library when not using XenAPI.
-    global XenAPI
-    if XenAPI is None:
-        XenAPI = __import__('XenAPI')
     url = FLAGS.xenapi_connection_url
     username = FLAGS.xenapi_connection_username
     password = FLAGS.xenapi_connection_password
@@ -110,6 +116,13 @@ class XenAPIConnection(object):
         self._vmops = VMOps(session)
         self._volumeops = VolumeOps(session)
 
+    def init_host(self):
+        #FIXME(armando): implement this
+        #NOTE(armando): would we need a method
+        #to call when shutting down the host?
+        #e.g. to do session logout?
+        pass
+
     def list_instances(self):
         """List VM instances"""
         return self._vmops.list_instances()
@@ -161,9 +174,14 @@ class XenAPISession(object):
     """The session to invoke XenAPI SDK calls"""
 
     def __init__(self, url, user, pw):
-        self._session = XenAPI.Session(url)
+        self.XenAPI = self.get_imported_xenapi()
+        self._session = self._create_session(url)
         self._session.login_with_password(user, pw)
 
+    def get_imported_xenapi(self):
+        """Stubout point. This can be replaced with a mock xenapi module."""
+        return __import__('XenAPI')
+
     def get_xenapi(self):
         """Return the xenapi object"""
         return self._session.xenapi
@@ -181,29 +199,33 @@ class XenAPISession(object):
 
     def async_call_plugin(self, plugin, fn, args):
         """Call Async.host.call_plugin on a background thread."""
-        return tpool.execute(_unwrap_plugin_exceptions,
+        return tpool.execute(self._unwrap_plugin_exceptions,
                              self._session.xenapi.Async.host.call_plugin,
                              self.get_xenapi_host(), plugin, fn, args)
 
-    def wait_for_task(self, instance_id, task):
-        """Return a Deferred that will give the result of the given task.
-        The task is polled until it completes."""
+    def wait_for_task(self, id, task):
+        """Return the result of the given task. The task is polled
+        until it completes."""
 
         done = event.Event()
-        loop = utils.LoopingCall(self._poll_task, instance_id, task, done)
+        loop = utils.LoopingCall(self._poll_task, id, task, done)
         loop.start(FLAGS.xenapi_task_poll_interval, now=True)
         rv = done.wait()
         loop.stop()
         return rv
 
-    def _poll_task(self, instance_id, task, done):
+    def _create_session(self, url):
+        """Stubout point. This can be replaced with a mock session."""
+        return self.XenAPI.Session(url)
+
+    def _poll_task(self, id, task, done):
         """Poll the given XenAPI task, and fire the given Deferred if we
         get a result."""
         try:
             name = self._session.xenapi.task.get_name_label(task)
             status = self._session.xenapi.task.get_status(task)
             action = dict(
-                instance_id=int(instance_id),
+                id=int(id),
                 action=name,
                 error=None)
             if status == "pending":
@@ -223,33 +245,32 @@ class XenAPISession(object):
                     task,
                     status,
                     error_info))
-                done.send_exception(XenAPI.Failure(error_info))
+                done.send_exception(self.XenAPI.Failure(error_info))
             db.instance_action_create(context.get_admin_context(), action)
-        except XenAPI.Failure, exc:
+        except self.XenAPI.Failure, exc:
             logging.warn(exc)
             done.send_exception(*sys.exc_info())
 
-
-def _unwrap_plugin_exceptions(func, *args, **kwargs):
-    """Parse exception details"""
-    try:
-        return func(*args, **kwargs)
-    except XenAPI.Failure, exc:
-        logging.debug(_("Got exception: %s"), exc)
-        if (len(exc.details) == 4 and
-            exc.details[0] == 'XENAPI_PLUGIN_EXCEPTION' and
-            exc.details[2] == 'Failure'):
-            params = None
-            try:
-                params = eval(exc.details[3])
-            except:
-                raise exc
-            raise XenAPI.Failure(params)
-        else:
+    def _unwrap_plugin_exceptions(self, func, *args, **kwargs):
+        """Parse exception details"""
+        try:
+            return func(*args, **kwargs)
+        except self.XenAPI.Failure, exc:
+            logging.debug(_("Got exception: %s"), exc)
+            if (len(exc.details) == 4 and
+                exc.details[0] == 'XENAPI_PLUGIN_EXCEPTION' and
+                exc.details[2] == 'Failure'):
+                params = None
+                try:
+                    params = eval(exc.details[3])
+                except:
+                    raise exc
+                raise self.XenAPI.Failure(params)
+            else:
+                raise
+        except xmlrpclib.ProtocolError, exc:
+            logging.debug(_("Got exception: %s"), exc)
             raise
-    except xmlrpclib.ProtocolError, exc:
-        logging.debug(_("Got exception: %s"), exc)
-        raise
 
 
 def _parse_xmlrpc_value(val):