From 659058bef7913254eca63e7f67a5d74ffe146e57 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Thu, 18 Nov 2010 00:11:45 +0000
Subject: fixes flatdhcp, updates nova.sh, allows for empty bridge device

---
 contrib/nova.sh           | 28 ++++++++++++++++++++--------
 nova/network/linux_net.py |  7 ++++---
 nova/network/manager.py   | 24 +++++++++++++++---------
 3 files changed, 39 insertions(+), 20 deletions(-)

diff --git a/contrib/nova.sh b/contrib/nova.sh
index 9bc36d6fb..abb8c7de0 100755
--- a/contrib/nova.sh
+++ b/contrib/nova.sh
@@ -17,11 +17,16 @@ if [ ! -n "$HOST_IP" ]; then
     #             you should explicitly set HOST_IP in your environment
     HOST_IP=`ifconfig  | grep -m 1 'inet addr:'| cut -d: -f2 | awk '{print $1}'`
 fi
-TEST=0
-USE_MYSQL=0
-MYSQL_PASS=nova
-USE_LDAP=0
-LIBVIRT_TYPE=qemu
+
+USE_MYSQL=${USE_MYSQL:-0}
+MYSQL_PASS=${MYSQL_PASS:-nova}
+TEST=${TEST:-0}
+USE_LDAP=${USE_LDAP:-0}
+LIBVIRT_TYPE=${LIBVIRT_TYPE:-qemu}
+NET_MAN=${NET_MAN:-VlanManager}
+# NOTE(vish): If you are using FlatDHCP make sure that this is not your
+#             public interface. You can comment it out for local usage
+BRIDGE_DEV=eth0
 
 if [ "$USE_MYSQL" == 1 ]; then
     SQL_CONN=mysql://root:$MYSQL_PASS@localhost/nova
@@ -41,6 +46,7 @@ cat >/etc/nova/nova-manage.conf << NOVA_CONF_EOF
 --nodaemon
 --dhcpbridge_flagfile=/etc/nova/nova-manage.conf
 --FAKE_subdomain=ec2
+--network_manager=nova.network.manager.$NET_MAN
 --cc_host=$HOST_IP
 --routing_source_ip=$HOST_IP
 --sql_connection=$SQL_CONN
@@ -48,6 +54,10 @@ cat >/etc/nova/nova-manage.conf << NOVA_CONF_EOF
 --libvirt_type=$LIBVIRT_TYPE
 NOVA_CONF_EOF
 
+if [ -n "$BRIDGE_DEV" ]; then
+    echo "--bridge_dev=$BRIDGE_DEV" >>/etc/nova/nova-manage.conf
+fi
+
 if [ "$CMD" == "branch" ]; then
     sudo apt-get install -y bzr
     rm -rf $NOVA_DIR
@@ -65,6 +75,8 @@ if [ "$CMD" == "install" ]; then
     sudo apt-get install -y dnsmasq open-iscsi kpartx kvm gawk iptables ebtables
     sudo apt-get install -y user-mode-linux kvm libvirt-bin
     sudo apt-get install -y screen iscsitarget euca2ools vlan curl rabbitmq-server
+    echo "ISCSITARGET_ENABLE=true" | sudo tee /etc/default/iscsitarget
+    sudo /etc/init.d/iscsitarget restart
     sudo modprobe kvm
     sudo /etc/init.d/libvirt-bin restart
     sudo apt-get install -y python-twisted python-sqlalchemy python-mox python-greenlet python-carrot
@@ -123,8 +135,8 @@ if [ "$CMD" == "run" ]; then
     $NOVA_DIR/bin/nova-manage project create admin admin
     # export environment variables for project 'admin' and user 'admin'
     $NOVA_DIR/bin/nova-manage project environment admin admin $NOVA_DIR/novarc
-    # create 3 small networks
-    $NOVA_DIR/bin/nova-manage network create 10.0.0.0/8 3 16
+    # create a small network
+    $NOVA_DIR/bin/nova-manage network create 10.0.0.0/8 1 32
 
     # nova api crashes if we start it with a regular screen command,
     # so send the start command by forcing text into the window.
@@ -135,7 +147,7 @@ if [ "$CMD" == "run" ]; then
     screen_it scheduler "$NOVA_DIR/bin/nova-scheduler --flagfile=/etc/nova/nova-manage.conf"
     screen_it volume "$NOVA_DIR/bin/nova-volume --flagfile=/etc/nova/nova-manage.conf"
     screen_it test ". $NOVA_DIR/novarc"
-    screen -x
+    screen -S nova -x
 fi
 
 if [ "$CMD" == "run" ] || [ "$CMD" == "terminate" ]; then
diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 7b323efa1..68037ed9a 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -42,7 +42,7 @@ flags.DEFINE_string('networks_path', utils.abspath('../networks'),
                     'Location to keep network config files')
 flags.DEFINE_string('public_interface', 'vlan1',
                     'Interface for public IP addresses')
-flags.DEFINE_string('bridge_dev', 'eth0',
+flags.DEFINE_string('bridge_dev', None,
                         'network device for bridges')
 flags.DEFINE_string('dhcpbridge', _bin_file('nova-dhcpbridge'),
                         'location of nova-dhcpbridge')
@@ -142,12 +142,13 @@ def ensure_vlan(vlan_num):
 def ensure_bridge(bridge, interface, net_attrs=None):
     """Create a bridge unless it already exists"""
     if not _device_exists(bridge):
-        logging.debug("Starting Bridge inteface for %s", interface)
+        logging.debug("Starting Bridge interface for %s", interface)
         _execute("sudo brctl addbr %s" % bridge)
         _execute("sudo brctl setfd %s 0" % bridge)
         # _execute("sudo brctl setageing %s 10" % bridge)
         _execute("sudo brctl stp %s off" % bridge)
-        _execute("sudo brctl addif %s %s" % (bridge, interface))
+        if interface:
+            _execute("sudo brctl addif %s %s" % (bridge, interface))
     if net_attrs:
         _execute("sudo ifconfig %s %s broadcast %s netmask %s up" % \
                 (bridge,
diff --git a/nova/network/manager.py b/nova/network/manager.py
index b033bb0a4..96f8cf50b 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -63,7 +63,7 @@ flags.DEFINE_string('flat_network_bridge', 'br100',
                     'Bridge for simple network instances')
 flags.DEFINE_string('flat_network_dns', '8.8.4.4',
                     'Dns for simple network')
-flags.DEFINE_string('flat_network_dhcp_start', '192.168.0.2',
+flags.DEFINE_string('flat_network_dhcp_start', '10.0.0.2',
                     'Dhcp start for FlatDhcp')
 flags.DEFINE_integer('vlan_start', 100, 'First VLAN for private networks')
 flags.DEFINE_integer('num_networks', 1000, 'Number of networks to support')
@@ -285,6 +285,7 @@ class FlatManager(NetworkManager):
             cidr = "%s/%s" % (fixed_net[start], significant_bits)
             project_net = IPy.IP(cidr)
             net = {}
+            net['bridge'] = FLAGS.flat_network_bridge
             net['cidr'] = cidr
             net['netmask'] = str(project_net.netmask())
             net['gateway'] = str(project_net[1])
@@ -307,17 +308,23 @@ class FlatManager(NetworkManager):
         """Called when this host becomes the host for a network."""
         net = {}
         net['injected'] = True
-        net['bridge'] = FLAGS.flat_network_bridge
         net['dns'] = FLAGS.flat_network_dns
         self.db.network_update(context, network_id, net)
 
 
-class FlatDHCPManager(NetworkManager):
+class FlatDHCPManager(FlatManager):
     """Flat networking with dhcp."""
 
+    def setup_compute_network(self, context, instance_id):
+        """Sets up matching network for compute hosts."""
+        network_ref = db.network_get_by_instance(context, instance_id)
+        self.driver.ensure_bridge(network_ref['bridge'],
+                                  FLAGS.bridge_dev,
+                                  network_ref)
+
     def setup_fixed_ip(self, context, address):
         """Setup dhcp for this network."""
-        network_ref = db.fixed_ip_get_by_address(context, address)
+        network_ref = db.fixed_ip_get_network(context, address)
         self.driver.update_dhcp(context, network_ref['id'])
 
     def deallocate_fixed_ip(self, context, address, *args, **kwargs):
@@ -326,11 +333,10 @@ class FlatDHCPManager(NetworkManager):
 
     def _on_set_network_host(self, context, network_id):
         """Called when this host becomes the host for a project."""
-        super(FlatDHCPManager, self)._on_set_network_host(context, network_id)
-        network_ref = self.db.network_get(context, network_id)
-        self.db.network_update(context,
-                               network_id,
-                               {'dhcp_start': FLAGS.flat_network_dhcp_start})
+        net = {}
+        net['dhcp_start'] = FLAGS.flat_network_dhcp_start
+        self.db.network_update(context, network_id, net)
+        network_ref = db.network_get(context, network_id)
         self.driver.ensure_bridge(network_ref['bridge'],
                                   FLAGS.bridge_dev,
                                   network_ref)
-- 
cgit 


From 693624831066af08dcf488d1528b017048fbde71 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Tue, 23 Nov 2010 17:56:43 +0000
Subject: changed bridge_dev to vlan_interface

---
 nova/network/linux_net.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 68037ed9a..d39ed9f86 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -42,8 +42,8 @@ flags.DEFINE_string('networks_path', utils.abspath('../networks'),
                     'Location to keep network config files')
 flags.DEFINE_string('public_interface', 'vlan1',
                     'Interface for public IP addresses')
-flags.DEFINE_string('bridge_dev', None,
-                        'network device for bridges')
+flags.DEFINE_string('vlan_interface', 'eth0',
+                    'network device for vlans')
 flags.DEFINE_string('dhcpbridge', _bin_file('nova-dhcpbridge'),
                         'location of nova-dhcpbridge')
 flags.DEFINE_string('routing_source_ip', '127.0.0.1',
@@ -134,7 +134,7 @@ def ensure_vlan(vlan_num):
     if not _device_exists(interface):
         logging.debug("Starting VLAN inteface %s", interface)
         _execute("sudo vconfig set_name_type VLAN_PLUS_VID_NO_PAD")
-        _execute("sudo vconfig add %s %s" % (FLAGS.bridge_dev, vlan_num))
+        _execute("sudo vconfig add %s %s" % (FLAGS.vlan_interface, vlan_num))
         _execute("sudo ifconfig %s up" % interface)
     return interface
 
-- 
cgit 


From 6811f824f7c1edd1b3882621d80fba54a2bf019d Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Tue, 23 Nov 2010 17:57:12 +0000
Subject: added flat_interface for flat_dhcp binding

---
 nova/network/manager.py | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/nova/network/manager.py b/nova/network/manager.py
index 96f8cf50b..8f13a8230 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -61,6 +61,8 @@ from nova import utils
 FLAGS = flags.FLAGS
 flags.DEFINE_string('flat_network_bridge', 'br100',
                     'Bridge for simple network instances')
+flags.DEFINE_string('flat_interface', None,
+                    'flat_dhcp will bridge into this interface if set')
 flags.DEFINE_string('flat_network_dns', '8.8.4.4',
                     'Dns for simple network')
 flags.DEFINE_string('flat_network_dhcp_start', '10.0.0.2',
@@ -319,7 +321,7 @@ class FlatDHCPManager(FlatManager):
         """Sets up matching network for compute hosts."""
         network_ref = db.network_get_by_instance(context, instance_id)
         self.driver.ensure_bridge(network_ref['bridge'],
-                                  FLAGS.bridge_dev,
+                                  FLAGS.flat_interface,
                                   network_ref)
 
     def setup_fixed_ip(self, context, address):
@@ -338,7 +340,7 @@ class FlatDHCPManager(FlatManager):
         self.db.network_update(context, network_id, net)
         network_ref = db.network_get(context, network_id)
         self.driver.ensure_bridge(network_ref['bridge'],
-                                  FLAGS.bridge_dev,
+                                  FLAGS.flat_interface,
                                   network_ref)
 
 
-- 
cgit 


From 015b7e5848c010ab86f067fb5dff462c2f34f4f9 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Tue, 23 Nov 2010 17:57:25 +0000
Subject: updated nova.sh

---
 contrib/nova.sh | 29 +++++++++++++++++++----------
 1 file changed, 19 insertions(+), 10 deletions(-)

diff --git a/contrib/nova.sh b/contrib/nova.sh
index abb8c7de0..8cbd5f605 100755
--- a/contrib/nova.sh
+++ b/contrib/nova.sh
@@ -1,11 +1,11 @@
 #!/usr/bin/env bash
 DIR=`pwd`
 CMD=$1
-SOURCE_BRANCH=lp:nova
+SOURCE_BRANCH=lp:~anso/nova/deploy
 if [ -n "$2" ]; then
     SOURCE_BRANCH=$2
 fi
-DIRNAME=nova
+DIRNAME=deploy
 NOVA_DIR=$DIR/$DIRNAME
 if [ -n "$3" ]; then
     NOVA_DIR=$DIR/$3
@@ -17,11 +17,10 @@ if [ ! -n "$HOST_IP" ]; then
     #             you should explicitly set HOST_IP in your environment
     HOST_IP=`ifconfig  | grep -m 1 'inet addr:'| cut -d: -f2 | awk '{print $1}'`
 fi
-
 USE_MYSQL=${USE_MYSQL:-0}
 MYSQL_PASS=${MYSQL_PASS:-nova}
 TEST=${TEST:-0}
-USE_LDAP=${USE_LDAP:-0}
+USE_LDAP=${USE_LDAP:-1}
 LIBVIRT_TYPE=${LIBVIRT_TYPE:-qemu}
 NET_MAN=${NET_MAN:-VlanManager}
 # NOTE(vish): If you are using FlatDHCP make sure that this is not your
@@ -48,14 +47,15 @@ cat >/etc/nova/nova-manage.conf << NOVA_CONF_EOF
 --FAKE_subdomain=ec2
 --network_manager=nova.network.manager.$NET_MAN
 --cc_host=$HOST_IP
+--cc_dmz=$HOST_IP
 --routing_source_ip=$HOST_IP
 --sql_connection=$SQL_CONN
 --auth_driver=nova.auth.$AUTH
 --libvirt_type=$LIBVIRT_TYPE
 NOVA_CONF_EOF
 
-if [ -n "$BRIDGE_DEV" ]; then
-    echo "--bridge_dev=$BRIDGE_DEV" >>/etc/nova/nova-manage.conf
+if [ -n "$FLAT_INTERFACE" ]; then
+    echo "--flat_interface=$FLAT_INTERFACE" >>/etc/nova/nova-manage.conf
 fi
 
 if [ "$CMD" == "branch" ]; then
@@ -72,9 +72,10 @@ if [ "$CMD" == "install" ]; then
     sudo apt-get install -y python-software-properties
     sudo add-apt-repository ppa:nova-core/ppa
     sudo apt-get update
-    sudo apt-get install -y dnsmasq open-iscsi kpartx kvm gawk iptables ebtables
+    sudo apt-get install -y dnsmasq kpartx kvm gawk iptables ebtables
     sudo apt-get install -y user-mode-linux kvm libvirt-bin
-    sudo apt-get install -y screen iscsitarget euca2ools vlan curl rabbitmq-server
+    sudo apt-get install -y screen euca2ools vlan curl rabbitmq-server
+    sudo apt-get install -y lvm2 iscsitarget open-iscsi
     echo "ISCSITARGET_ENABLE=true" | sudo tee /etc/default/iscsitarget
     sudo /etc/init.d/iscsitarget restart
     sudo modprobe kvm
@@ -119,6 +120,9 @@ if [ "$CMD" == "run" ]; then
     rm -rf $NOVA_DIR/networks
     mkdir -p $NOVA_DIR/networks
     $NOVA_DIR/tools/clean-vlans
+    sleep 3
+    ifdown eth0
+    ifup eth0
     if [ ! -d "$NOVA_DIR/images" ]; then
         ln -s $DIR/images $NOVA_DIR/images
     fi
@@ -147,6 +151,11 @@ if [ "$CMD" == "run" ]; then
     screen_it scheduler "$NOVA_DIR/bin/nova-scheduler --flagfile=/etc/nova/nova-manage.conf"
     screen_it volume "$NOVA_DIR/bin/nova-volume --flagfile=/etc/nova/nova-manage.conf"
     screen_it test ". $NOVA_DIR/novarc"
+
+    sleep 3
+
+    $NOVA_DIR/bin/nova-manage service enable `hostname` nova-compute
+    $NOVA_DIR/bin/nova-manage service enable `hostname` nova-volume
     screen -S nova -x
 fi
 
@@ -154,12 +163,13 @@ if [ "$CMD" == "run" ] || [ "$CMD" == "terminate" ]; then
     # shutdown instances
     . $NOVA_DIR/novarc; euca-describe-instances | grep i- | cut -f2 | xargs euca-terminate-instances
     sleep 2
+    # delete volumes
+    . $NOVA_DIR/novarc; euca-describe-volumes | grep vol- | cut -f2 | xargs -n1 euca-delete-volume
 fi
 
 if [ "$CMD" == "run" ] || [ "$CMD" == "clean" ]; then
     screen -S nova -X quit
     rm *.pid*
-    $NOVA_DIR/tools/setup_iptables.sh clear
 fi
 
 if [ "$CMD" == "scrub" ]; then
@@ -169,5 +179,4 @@ if [ "$CMD" == "scrub" ]; then
     else
         virsh list | grep i- | awk '{print \$1}' | xargs -n1 virsh destroy
     fi
-    vblade-persist ls | grep vol- | awk '{print \$1\" \"\$2}' | xargs -n2 vblade-persist destroy
 fi
-- 
cgit 


From 84521218b84d2eed307364c9efc9f6f2ee212aac Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Tue, 23 Nov 2010 23:18:02 +0000
Subject: docstrings, more flags, breakout of metadata forwarding

---
 nova/network/linux_net.py | 10 +++----
 nova/network/manager.py   | 67 ++++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 65 insertions(+), 12 deletions(-)

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index d39ed9f86..b30ddb667 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -53,15 +53,15 @@ flags.DEFINE_bool('use_nova_chains', False,
 
 DEFAULT_PORTS = [("tcp", 80), ("tcp", 22), ("udp", 1194), ("tcp", 443)]
 
-
-def init_host():
-    """Basic networking setup goes here"""
-    # NOTE(devcamcar): Cloud public DNAT entries, CloudPipe port
-    # forwarding entries and a default DNAT entry.
+def metadata_forward():
+    """Create forwarding rule for metadata"""
     _confirm_rule("PREROUTING", "-t nat -s 0.0.0.0/0 "
              "-d 169.254.169.254/32 -p tcp -m tcp --dport 80 -j DNAT "
              "--to-destination %s:%s" % (FLAGS.cc_host, FLAGS.cc_port))
 
+
+def init_host():
+    """Basic networking setup goes here"""
     # NOTE(devcamcar): Cloud public SNAT entries and the default
     # SNAT rule for outbound traffic.
     _confirm_rule("POSTROUTING", "-t nat -s %s "
diff --git a/nova/network/manager.py b/nova/network/manager.py
index 8f13a8230..f9489d2ad 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -27,6 +27,7 @@ topologies.  All of the network commands are issued to a subclass of
 
 :network_driver:  Driver to use for network creation
 :flat_network_bridge:  Bridge device for simple network instances
+:flat_interface:  FlatDhcp will bridge into this interface if set
 :flat_network_dns:  Dns for simple network
 :flat_network_dhcp_start:  Dhcp start for FlatDhcp
 :vlan_start:  First VLAN for private networks
@@ -61,10 +62,12 @@ from nova import utils
 FLAGS = flags.FLAGS
 flags.DEFINE_string('flat_network_bridge', 'br100',
                     'Bridge for simple network instances')
-flags.DEFINE_string('flat_interface', None,
-                    'flat_dhcp will bridge into this interface if set')
 flags.DEFINE_string('flat_network_dns', '8.8.4.4',
                     'Dns for simple network')
+flags.DEFINE_bool('flat_injected', True,
+                  'Whether to attempt to inject network setup into guest')
+flags.DEFINE_string('flat_interface', None,
+                    'FlatDhcp will bridge into this interface if set')
 flags.DEFINE_string('flat_network_dhcp_start', '10.0.0.2',
                     'Dhcp start for FlatDhcp')
 flags.DEFINE_integer('vlan_start', 100, 'First VLAN for private networks')
@@ -177,9 +180,11 @@ class NetworkManager(manager.Manager):
         if instance_ref['mac_address'] != mac:
             raise exception.Error("IP %s leased to bad mac %s vs %s" %
                                   (address, instance_ref['mac_address'], mac))
+        now = datetime.datetime.utcnow()
         self.db.fixed_ip_update(context,
                                 fixed_ip_ref['address'],
-                                {'leased': True})
+                                {'leased': True,
+                                 'updated_at': now})
         if not fixed_ip_ref['allocated']:
             logging.warn("IP %s leased that was already deallocated", address)
 
@@ -248,7 +253,31 @@ class NetworkManager(manager.Manager):
 
 
 class FlatManager(NetworkManager):
-    """Basic network where no vlans are used."""
+    """Basic network where no vlans are used.
+
+    FlatManager does not do any bridge or vlan creation.  The user is
+    responsible for setting up whatever bridge is specified in
+    flat_network_bridge (br100 by default).  This bridge needs to be created
+    on all compute hosts.
+
+    The idea is to create a single network for the host with a command like:
+    nova-manage network create 192.168.0.0/24 256 1. Creating multiple
+    networks for for one manager is currently not supported, but could be
+    added by modifying allocate_fixed_ip and get_network to get the a network
+    with new logic instead of network_get_by_bridge. Arbitrary lists of
+    addresses in a single network can be accomplished with manual db editing.
+
+    If flat_injected is True, the compute host will attempt to inject network
+    config into the guest.  It attempts to modify /etc/network/interfaces and
+    currently only works on debian based systems. To support a wider range of
+    OSes, some other method may need to be devised to let the guest know which
+    ip it should be using so that it can configure itself. Perhaps an attached
+    disk or serial device with configuration info.
+
+    Metadata forwarding must be handled by the gateway, and since nova does
+    not do any setup in this mode, it must be done manually.  Requests to
+    169.254.169.254 port 80 will need to be forwarded to the api server.
+    """
 
     def allocate_fixed_ip(self, context, instance_id, *args, **kwargs):
         """Gets a fixed ip from the pool."""
@@ -309,13 +338,25 @@ class FlatManager(NetworkManager):
     def _on_set_network_host(self, context, network_id):
         """Called when this host becomes the host for a network."""
         net = {}
-        net['injected'] = True
+        net['injected'] = FLAGS.flat_injected
         net['dns'] = FLAGS.flat_network_dns
         self.db.network_update(context, network_id, net)
 
 
 class FlatDHCPManager(FlatManager):
-    """Flat networking with dhcp."""
+    """Flat networking with dhcp.
+
+    FlatDHCPManager will start up one dhcp server to give out addresses.
+    It never injects network settings into the guest. Otherwise it behaves
+    like FlatDHCPManager.
+    """
+
+    def init_host(self):
+        """Do any initialization that needs to be run if this is a
+        standalone service.
+        """
+        super(FlatDHCPManager, self).init_host()
+        self.driver.metadata_forward()
 
     def setup_compute_network(self, context, instance_id):
         """Sets up matching network for compute hosts."""
@@ -345,7 +386,18 @@ class FlatDHCPManager(FlatManager):
 
 
 class VlanManager(NetworkManager):
-    """Vlan network with dhcp."""
+    """Vlan network with dhcp.
+
+    VlanManager is the most complicated.  It will create a host-managed
+    vlan for each project.  Each project gets its own subnet.  The networks
+    and associated subnets are created with nova-manage using a command like:
+    nova-manage network create 10.0.0.0/8 16 3.  This will create 3 networks
+    of 16 addresses from the beginning of the 10.0.0.0 range.
+
+    A dhcp server is run for each subnet, so each project will have its own.
+    For this mode to be useful, each project will need a vpn to access the
+    instances in its subnet.
+    """
 
     @defer.inlineCallbacks
     def periodic_tasks(self, context=None):
@@ -365,6 +417,7 @@ class VlanManager(NetworkManager):
         standalone service.
         """
         super(VlanManager, self).init_host()
+        self.driver.metadata_forward()
         self.driver.init_host()
 
     def allocate_fixed_ip(self, context, instance_id, *args, **kwargs):
-- 
cgit 


From 521dd52e49feeae04108f3e21480f42456b4e4c7 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Tue, 23 Nov 2010 23:56:26 +0000
Subject: fix typos in docstring

---
 nova/network/manager.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nova/network/manager.py b/nova/network/manager.py
index f9489d2ad..a7298b47f 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -261,7 +261,7 @@ class FlatManager(NetworkManager):
     on all compute hosts.
 
     The idea is to create a single network for the host with a command like:
-    nova-manage network create 192.168.0.0/24 256 1. Creating multiple
+    nova-manage network create 192.168.0.0/24 1 256. Creating multiple
     networks for for one manager is currently not supported, but could be
     added by modifying allocate_fixed_ip and get_network to get the a network
     with new logic instead of network_get_by_bridge. Arbitrary lists of
@@ -391,7 +391,7 @@ class VlanManager(NetworkManager):
     VlanManager is the most complicated.  It will create a host-managed
     vlan for each project.  Each project gets its own subnet.  The networks
     and associated subnets are created with nova-manage using a command like:
-    nova-manage network create 10.0.0.0/8 16 3.  This will create 3 networks
+    nova-manage network create 10.0.0.0/8 3 16.  This will create 3 networks
     of 16 addresses from the beginning of the 10.0.0.0 range.
 
     A dhcp server is run for each subnet, so each project will have its own.
-- 
cgit 


From d62d3f7bcf06802662f77f8013c9da99eccec0a7 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Wed, 24 Nov 2010 00:16:47 +0000
Subject: pep8

---
 nova/network/linux_net.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 7dbf6b733..391abfb76 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -53,6 +53,7 @@ flags.DEFINE_bool('use_nova_chains', False,
 
 DEFAULT_PORTS = [("tcp", 80), ("tcp", 22), ("udp", 1194), ("tcp", 443)]
 
+
 def metadata_forward():
     """Create forwarding rule for metadata"""
     _confirm_rule("PREROUTING", "-t nat -s 0.0.0.0/0 "
-- 
cgit 


From a44ee54dfe3f243a44636e9224082e86fdee452f Mon Sep 17 00:00:00 2001
From: Armando Migliaccio <armando.migliaccio@citrix.com>
Date: Sat, 27 Nov 2010 12:56:19 +0000
Subject: first cut of the refactoring of the XenAPIConnection class. Currently
 the class merged both the code for managing the XenAPI connection and the
 business logic for implementing Nova operations. If left like this, it would 
 eventually become difficult to read, maintain and extend. The file was
 getting kind of big and cluttered, so a quick refactoring now will save a lot
 of headaches later.

---
 nova/virt/xenapi.py             | 323 +++++------------------------
 nova/virt/xenapi/power_state.py |  26 +++
 nova/virt/xenapi/xenapi.py      | 439 ++++++++++++++++++++++++++++++++++++++++
 3 files changed, 515 insertions(+), 273 deletions(-)
 create mode 100644 nova/virt/xenapi/power_state.py
 create mode 100644 nova/virt/xenapi/xenapi.py

diff --git a/nova/virt/xenapi.py b/nova/virt/xenapi.py
index 3169562a5..93c119205 100644
--- a/nova/virt/xenapi.py
+++ b/nova/virt/xenapi.py
@@ -54,14 +54,9 @@ from twisted.internet import defer
 from twisted.internet import reactor
 from twisted.internet import task
 
-from nova import db
-from nova import flags
-from nova import process
-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 xenapi import power_state
+from xenapi import vmops
+from xenapi import volumeops
 
 XenAPI = None
 
@@ -86,14 +81,6 @@ flags.DEFINE_float('xenapi_task_poll_interval',
                    'connection_type=xenapi.')
 
 
-XENAPI_POWER_STATE = {
-    'Halted': power_state.SHUTDOWN,
-    'Running': power_state.RUNNING,
-    'Paused': power_state.PAUSED,
-    'Suspended': power_state.SHUTDOWN,  # FIXME
-    'Crashed': power_state.CRASHED}
-
-
 def get_connection(_):
     """Note that XenAPI doesn't have a read-only connection mode, so
     the read_only parameter is ignored."""
@@ -115,273 +102,83 @@ def get_connection(_):
 
 class XenAPIConnection(object):
     def __init__(self, url, user, pw):
-        self._conn = XenAPI.Session(url)
-        self._conn.login_with_password(user, pw)
-
+        self._session = XenAPISession(url, user, pw)
+        self._vmops = VMOps(sef._session)
+        self._volumeops = volumeOps(self._session)
+        
     def list_instances(self):
-        return [self._conn.xenapi.VM.get_name_label(vm) \
-                for vm in self._conn.xenapi.VM.get_all()]
-
-    @defer.inlineCallbacks
+        return self._vmops.list_instances()
+    
     def spawn(self, instance):
-        vm = yield self._lookup(instance.name)
-        if vm is not None:
-            raise Exception('Attempted to create non-unique name %s' %
-                            instance.name)
-
-        network = db.project_get_network(None, instance.project_id)
-        network_ref = \
-            yield self._find_network_with_bridge(network.bridge)
-
-        user = AuthManager().get_user(instance.user_id)
-        project = AuthManager().get_project(instance.project_id)
-        vdi_uuid = yield self._fetch_image(
-            instance.image_id, user, project, True)
-        kernel = yield self._fetch_image(
-            instance.kernel_id, user, project, False)
-        ramdisk = yield self._fetch_image(
-            instance.ramdisk_id, user, project, False)
-        vdi_ref = yield self._call_xenapi('VDI.get_by_uuid', vdi_uuid)
-
-        vm_ref = yield self._create_vm(instance, kernel, ramdisk)
-        yield self._create_vbd(vm_ref, vdi_ref, 0, True)
-        if network_ref:
-            yield self._create_vif(vm_ref, network_ref, instance.mac_address)
-        logging.debug('Starting VM %s...', vm_ref)
-        yield self._call_xenapi('VM.start', vm_ref, False, False)
-        logging.info('Spawning VM %s created %s.', instance.name, vm_ref)
-
-    @defer.inlineCallbacks
-    def _create_vm(self, 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'])
-        rec = {
-            'name_label': instance.name,
-            'name_description': '',
-            'is_a_template': False,
-            'memory_static_min': '0',
-            'memory_static_max': mem,
-            'memory_dynamic_min': mem,
-            'memory_dynamic_max': mem,
-            'VCPUs_at_startup': vcpus,
-            'VCPUs_max': vcpus,
-            'VCPUs_params': {},
-            'actions_after_shutdown': 'destroy',
-            'actions_after_reboot': 'restart',
-            'actions_after_crash': 'destroy',
-            'PV_bootloader': '',
-            'PV_kernel': kernel,
-            'PV_ramdisk': ramdisk,
-            'PV_args': 'root=/dev/xvda1',
-            'PV_bootloader_args': '',
-            'PV_legacy_args': '',
-            'HVM_boot_policy': '',
-            'HVM_boot_params': {},
-            'platform': {},
-            'PCI_bus': '',
-            'recommendations': '',
-            'affinity': '',
-            'user_version': '0',
-            'other_config': {},
-            }
-        logging.debug('Created VM %s...', instance.name)
-        vm_ref = yield self._call_xenapi('VM.create', rec)
-        logging.debug('Created VM %s as %s.', instance.name, vm_ref)
-        defer.returnValue(vm_ref)
-
-    @defer.inlineCallbacks
-    def _create_vbd(self, 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
-        vbd_rec['userdevice'] = str(userdevice)
-        vbd_rec['bootable'] = bootable
-        vbd_rec['mode'] = 'RW'
-        vbd_rec['type'] = 'disk'
-        vbd_rec['unpluggable'] = True
-        vbd_rec['empty'] = False
-        vbd_rec['other_config'] = {}
-        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)
-        vbd_ref = yield self._call_xenapi('VBD.create', vbd_rec)
-        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
-                      vdi_ref)
-        defer.returnValue(vbd_ref)
-
-    @defer.inlineCallbacks
-    def _create_vif(self, 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
-        vif_rec['VM'] = vm_ref
-        vif_rec['MAC'] = mac_address
-        vif_rec['MTU'] = '1500'
-        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,
-                      network_ref)
-        vif_ref = yield self._call_xenapi('VIF.create', vif_rec)
-        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
-                      vm_ref, network_ref)
-        defer.returnValue(vif_ref)
-
-    @defer.inlineCallbacks
-    def _find_network_with_bridge(self, bridge):
-        expr = 'field "bridge" = "%s"' % bridge
-        networks = yield self._call_xenapi('network.get_all_records_where',
-                                           expr)
-        if len(networks) == 1:
-            defer.returnValue(networks.keys()[0])
-        elif len(networks) > 1:
-            raise Exception('Found non-unique network for bridge %s' % bridge)
-        else:
-            raise Exception('Found no network for bridge %s' % bridge)
-
-    @defer.inlineCallbacks
-    def _fetch_image(self, image, user, project, use_sr):
-        """use_sr: True to put the image as a VDI in an SR, False to place
-        it on dom0's filesystem.  The former is for VM disks, the latter for
-        its kernel and ramdisk (if external kernels are being used).
-        Returns a Deferred that gives the new VDI UUID."""
-
-        url = images.image_url(image)
-        access = AuthManager().get_access_key(user, project)
-        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
-        args['username'] = access
-        args['password'] = user.secret
-        if use_sr:
-            args['add_partition'] = 'true'
-        task = yield self._async_call_plugin('objectstore', fn, args)
-        uuid = yield self._wait_for_task(task)
-        defer.returnValue(uuid)
-
-    @defer.inlineCallbacks
+        self._vmops.spawn(instance)
+    
     def reboot(self, instance):
-        vm = yield self._lookup(instance.name)
-        if vm is None:
-            raise Exception('instance not present %s' % instance.name)
-        task = yield self._call_xenapi('Async.VM.clean_reboot', vm)
-        yield self._wait_for_task(task)
+        self._vmops.reboot(instance)   
 
-    @defer.inlineCallbacks
     def destroy(self, instance):
-        vm = yield self._lookup(instance.name)
-        if vm is None:
-            # Don't complain, just return.  This lets us clean up instances
-            # that have already disappeared from the underlying platform.
-            defer.returnValue(None)
-        # Get the VDIs related to the VM
-        vdis = yield self._lookup_vm_vdis(vm)
-        try:
-            task = yield self._call_xenapi('Async.VM.hard_shutdown', vm)
-            yield self._wait_for_task(task)
-        except Exception, exc:
-            logging.warn(exc)
-        # Disk clean-up
-        if vdis:
-            for vdi in vdis:
-                try:
-                    task = yield self._call_xenapi('Async.VDI.destroy', vdi)
-                    yield self._wait_for_task(task)
-                except Exception, exc:
-                    logging.warn(exc)
-        try:
-            task = yield self._call_xenapi('Async.VM.destroy', vm)
-            yield self._wait_for_task(task)
-        except Exception, exc:
-            logging.warn(exc)
-
+        self._vmops.destroy(instance)
+    
     def get_info(self, instance_id):
-        vm = self._lookup_blocking(instance_id)
-        if vm is None:
-            raise Exception('instance not present %s' % instance_id)
-        rec = self._conn.xenapi.VM.get_record(vm)
-        return {'state': XENAPI_POWER_STATE[rec['power_state']],
-                'max_mem': long(rec['memory_static_max']) >> 10,
-                'mem': long(rec['memory_dynamic_max']) >> 10,
-                'num_cpu': rec['VCPUs_max'],
-                'cpu_time': 0}
-
+        return self._vmops.get_info(instance_id)
+        
     def get_console_output(self, instance):
-        return 'FAKE CONSOLE OUTPUT'
+        return self._vmops.get_console_output(instance)   
+        
+    def attach_volume(self, instance_name, device_path, mountpoint):
+        return self._volumeops.attach_volume(instance_name, device_path, mountpoint)
+
+    def detach_volume(self, instance_name, mountpoint):
+        return self._volumeops.detach_volume(instance_name, mountpoint)
+
+
+class XenAPISession(object):
+    def __init__(self, url, user, pw):
+        self._session = XenAPI.Session(url)
+        self._session.login_with_password(user, pw)
 
     @utils.deferredToThread
-    def _lookup(self, i):
-        return self._lookup_blocking(i)
-
-    def _lookup_blocking(self, i):
-        vms = self._conn.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)
-        else:
-            return vms[0]
+    def call_xenapi(self, method, *args):
+        """Call the specified XenAPI method on a background thread.  Returns
+        a Deferred for the result."""
+        f = self._session.xenapi
+        for m in method.split('.'):
+            f = f.__getattr__(m)
+        return f(*args)
 
     @utils.deferredToThread
-    def _lookup_vm_vdis(self, vm):
-        return self._lookup_vm_vdis_blocking(vm)
-
-    def _lookup_vm_vdis_blocking(self, vm):
-        # Firstly we get the VBDs, then the VDIs.
-        # TODO: do we leave the read-only devices?
-        vbds = self._conn.xenapi.VM.get_VBDs(vm)
-        vdis = []
-        if vbds:
-            for vbd in vbds:
-                try:
-                    vdi = self._conn.xenapi.VBD.get_VDI(vbd)
-                    # Test valid VDI
-                    record = self._conn.xenapi.VDI.get_record(vdi)
-                except Exception, exc:
-                    logging.warn(exc)
-                else:
-                    vdis.append(vdi)
-            if len(vdis) > 0:
-                return vdis
-            else:
-                return None
+    def async_call_plugin(self, plugin, fn, args):
+        """Call Async.host.call_plugin on a background thread.  Returns a
+        Deferred with the task reference."""
+        return _unwrap_plugin_exceptions(
+            self._session.xenapi.Async.host.call_plugin,
+            self._get_xenapi_host(), plugin, fn, args)
 
-    def _wait_for_task(self, task):
+    def get_xenapi_host(self):
+        return self._session.xenapi.session.get_this_host(self._session.handle)
+
+    def wait_for_task(self, task):
         """Return a Deferred that will give the result of the given task.
         The task is polled until it completes."""
         d = defer.Deferred()
         reactor.callLater(0, self._poll_task, task, d)
         return d
-
+        
     @utils.deferredToThread
     def _poll_task(self, task, deferred):
         """Poll the given XenAPI task, and fire the given Deferred if we
         get a result."""
         try:
             #logging.debug('Polling task %s...', task)
-            status = self._conn.xenapi.task.get_status(task)
+            status = self._session.xenapi.task.get_status(task)
             if status == 'pending':
                 reactor.callLater(FLAGS.xenapi_task_poll_interval,
                                   self._poll_task, task, deferred)
             elif status == 'success':
-                result = self._conn.xenapi.task.get_result(task)
+                result = self._session.xenapi.task.get_result(task)
                 logging.info('Task %s status: success.  %s', task, result)
                 deferred.callback(_parse_xmlrpc_value(result))
             else:
-                error_info = self._conn.xenapi.task.get_error_info(task)
+                error_info = self._session.xenapi.task.get_error_info(task)
                 logging.warn('Task %s status: %s.  %s', task, status,
                              error_info)
                 deferred.errback(XenAPI.Failure(error_info))
@@ -390,26 +187,6 @@ class XenAPIConnection(object):
             logging.warn(exc)
             deferred.errback(exc)
 
-    @utils.deferredToThread
-    def _call_xenapi(self, method, *args):
-        """Call the specified XenAPI method on a background thread.  Returns
-        a Deferred for the result."""
-        f = self._conn.xenapi
-        for m in method.split('.'):
-            f = f.__getattr__(m)
-        return f(*args)
-
-    @utils.deferredToThread
-    def _async_call_plugin(self, plugin, fn, args):
-        """Call Async.host.call_plugin on a background thread.  Returns a
-        Deferred with the task reference."""
-        return _unwrap_plugin_exceptions(
-            self._conn.xenapi.Async.host.call_plugin,
-            self._get_xenapi_host(), plugin, fn, args)
-
-    def _get_xenapi_host(self):
-        return self._conn.xenapi.session.get_this_host(self._conn.handle)
-
 
 def _unwrap_plugin_exceptions(func, *args, **kwargs):
     try:
diff --git a/nova/virt/xenapi/power_state.py b/nova/virt/xenapi/power_state.py
new file mode 100644
index 000000000..d2d8fba42
--- /dev/null
+++ b/nova/virt/xenapi/power_state.py
@@ -0,0 +1,26 @@
+# 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.
+
+from nova.compute import power_state
+
+
+XENAPI_POWER_STATE = {
+    'Halted': power_state.SHUTDOWN,
+    'Running': power_state.RUNNING,
+    'Paused': power_state.PAUSED,
+    'Suspended': power_state.SHUTDOWN,  # FIXME
+    'Crashed': power_state.CRASHED}
+    
\ No newline at end of file
diff --git a/nova/virt/xenapi/xenapi.py b/nova/virt/xenapi/xenapi.py
new file mode 100644
index 000000000..ddbef4303
--- /dev/null
+++ b/nova/virt/xenapi/xenapi.py
@@ -0,0 +1,439 @@
+# 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.
+
+"""
+A connection to XenServer or Xen Cloud Platform.
+
+The concurrency model for this class is as follows:
+
+All XenAPI calls are on a thread (using t.i.t.deferToThread, via the decorator
+deferredToThread).  They are remote calls, and so may hang for the usual
+reasons.  They should not be allowed to block the reactor thread.
+
+All long-running XenAPI calls (VM.start, VM.reboot, etc) are called async
+(using XenAPI.VM.async_start etc).  These return a task, which can then be
+polled for completion.  Polling is handled using reactor.callLater.
+
+This combination of techniques means that we don't block the reactor thread at
+all, and at the same time we don't hold lots of threads waiting for
+long-running operations.
+
+FIXME: get_info currently doesn't conform to these rules, and will block the
+reactor thread if the VM.get_by_name_label or VM.get_record calls block.
+
+**Related Flags**
+
+:xenapi_connection_url:  URL for connection to XenServer/Xen Cloud Platform.
+:xenapi_connection_username:  Username for connection to XenServer/Xen Cloud
+                              Platform (default: root).
+:xenapi_connection_password:  Password for connection to XenServer/Xen Cloud
+                              Platform.
+:xenapi_task_poll_interval:  The interval (seconds) used for polling of
+                             remote tasks (Async.VM.start, etc)
+                             (default: 0.5).
+
+"""
+
+import logging
+import xmlrpclib
+
+from twisted.internet import defer
+from twisted.internet import reactor
+from twisted.internet import task
+
+from nova import db
+from nova import flags
+from nova import process
+from nova import utils
+from nova.auth.manager import AuthManager  # wrap this one
+from nova.compute import instance_types  # wrap this one
+from xenapi import power_state
+from nova.virt import images   # wrap this one
+
+XenAPI = None
+
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('xenapi_connection_url',
+                    None,
+                    'URL for connection to XenServer/Xen Cloud Platform.'
+                    ' Required if connection_type=xenapi.')
+flags.DEFINE_string('xenapi_connection_username',
+                    'root',
+                    'Username for connection to XenServer/Xen Cloud Platform.'
+                    ' Used only if connection_type=xenapi.')
+flags.DEFINE_string('xenapi_connection_password',
+                    None,
+                    'Password for connection to XenServer/Xen Cloud Platform.'
+                    ' Used only if connection_type=xenapi.')
+flags.DEFINE_float('xenapi_task_poll_interval',
+                   0.5,
+                   'The interval used for polling of remote tasks '
+                   '(Async.VM.start, etc).  Used only if '
+                   'connection_type=xenapi.')
+
+
+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
+    if not url or password is None:
+        raise Exception('Must specify xenapi_connection_url, '
+                        'xenapi_connection_username (optionally), and '
+                        'xenapi_connection_password to use '
+                        'connection_type=xenapi')
+    return XenAPIConnection(url, username, password)
+
+
+class XenAPISession(object):
+    def __init__(self, url, user, pw):
+        self._session = XenAPI.Session(url)
+        self._session.login_with_password(user, pw)
+        
+    def session(self):
+    return self._session
+    
+    def list_instances(self):
+        return [self._session.xenapi.VM.get_name_label(vm) \
+                for vm in self._session.xenapi.VM.get_all()]
+
+    @defer.inlineCallbacks
+    def spawn(self, instance):
+        vm = yield self._lookup(instance.name)
+        if vm is not None:
+            raise Exception('Attempted to create non-unique name %s' %
+                            instance.name)
+
+        network = db.project_get_network(None, instance.project_id)
+        network_ref = \
+            yield self._find_network_with_bridge(network.bridge)
+
+        user = AuthManager().get_user(instance.user_id)
+        project = AuthManager().get_project(instance.project_id)
+        vdi_uuid = yield self._fetch_image(
+            instance.image_id, user, project, True)
+        kernel = yield self._fetch_image(
+            instance.kernel_id, user, project, False)
+        ramdisk = yield self._fetch_image(
+            instance.ramdisk_id, user, project, False)
+        vdi_ref = yield self._call_xenapi('VDI.get_by_uuid', vdi_uuid)
+
+        vm_ref = yield self._create_vm(instance, kernel, ramdisk)
+        yield self._create_vbd(vm_ref, vdi_ref, 0, True)
+        if network_ref:
+            yield self._create_vif(vm_ref, network_ref, instance.mac_address)
+        logging.debug('Starting VM %s...', vm_ref)
+        yield self._call_xenapi('VM.start', vm_ref, False, False)
+        logging.info('Spawning VM %s created %s.', instance.name, vm_ref)
+
+    @defer.inlineCallbacks
+    def _create_vm(self, 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'])
+        rec = {
+            'name_label': instance.name,
+            'name_description': '',
+            'is_a_template': False,
+            'memory_static_min': '0',
+            'memory_static_max': mem,
+            'memory_dynamic_min': mem,
+            'memory_dynamic_max': mem,
+            'VCPUs_at_startup': vcpus,
+            'VCPUs_max': vcpus,
+            'VCPUs_params': {},
+            'actions_after_shutdown': 'destroy',
+            'actions_after_reboot': 'restart',
+            'actions_after_crash': 'destroy',
+            'PV_bootloader': '',
+            'PV_kernel': kernel,
+            'PV_ramdisk': ramdisk,
+            'PV_args': 'root=/dev/xvda1',
+            'PV_bootloader_args': '',
+            'PV_legacy_args': '',
+            'HVM_boot_policy': '',
+            'HVM_boot_params': {},
+            'platform': {},
+            'PCI_bus': '',
+            'recommendations': '',
+            'affinity': '',
+            'user_version': '0',
+            'other_config': {},
+            }
+        logging.debug('Created VM %s...', instance.name)
+        vm_ref = yield self._call_xenapi('VM.create', rec)
+        logging.debug('Created VM %s as %s.', instance.name, vm_ref)
+        defer.returnValue(vm_ref)
+
+    @defer.inlineCallbacks
+    def _create_vbd(self, 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
+        vbd_rec['userdevice'] = str(userdevice)
+        vbd_rec['bootable'] = bootable
+        vbd_rec['mode'] = 'RW'
+        vbd_rec['type'] = 'disk'
+        vbd_rec['unpluggable'] = True
+        vbd_rec['empty'] = False
+        vbd_rec['other_config'] = {}
+        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)
+        vbd_ref = yield self._call_xenapi('VBD.create', vbd_rec)
+        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
+                      vdi_ref)
+        defer.returnValue(vbd_ref)
+
+    @defer.inlineCallbacks
+    def _create_vif(self, 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
+        vif_rec['VM'] = vm_ref
+        vif_rec['MAC'] = mac_address
+        vif_rec['MTU'] = '1500'
+        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,
+                      network_ref)
+        vif_ref = yield self._call_xenapi('VIF.create', vif_rec)
+        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
+                      vm_ref, network_ref)
+        defer.returnValue(vif_ref)
+
+    @defer.inlineCallbacks
+    def _find_network_with_bridge(self, bridge):
+        expr = 'field "bridge" = "%s"' % bridge
+        networks = yield self._call_xenapi('network.get_all_records_where',
+                                           expr)
+        if len(networks) == 1:
+            defer.returnValue(networks.keys()[0])
+        elif len(networks) > 1:
+            raise Exception('Found non-unique network for bridge %s' % bridge)
+        else:
+            raise Exception('Found no network for bridge %s' % bridge)
+
+    @defer.inlineCallbacks
+    def _fetch_image(self, image, user, project, use_sr):
+        """use_sr: True to put the image as a VDI in an SR, False to place
+        it on dom0's filesystem.  The former is for VM disks, the latter for
+        its kernel and ramdisk (if external kernels are being used).
+        Returns a Deferred that gives the new VDI UUID."""
+
+        url = images.image_url(image)
+        access = AuthManager().get_access_key(user, project)
+        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
+        args['username'] = access
+        args['password'] = user.secret
+        if use_sr:
+            args['add_partition'] = 'true'
+        task = yield self._async_call_plugin('objectstore', fn, args)
+        uuid = yield self._wait_for_task(task)
+        defer.returnValue(uuid)
+
+    @defer.inlineCallbacks
+    def reboot(self, instance):
+        vm = yield self._lookup(instance.name)
+        if vm is None:
+            raise Exception('instance not present %s' % instance.name)
+        task = yield self._call_xenapi('Async.VM.clean_reboot', vm)
+        yield self._wait_for_task(task)
+
+    @defer.inlineCallbacks
+    def destroy(self, instance):
+        vm = yield self._lookup(instance.name)
+        if vm is None:
+            # Don't complain, just return.  This lets us clean up instances
+            # that have already disappeared from the underlying platform.
+            defer.returnValue(None)
+        # Get the VDIs related to the VM
+        vdis = yield self._lookup_vm_vdis(vm)
+        try:
+            task = yield self._call_xenapi('Async.VM.hard_shutdown', vm)
+            yield self._wait_for_task(task)
+        except Exception, exc:
+            logging.warn(exc)
+        # Disk clean-up
+        if vdis:
+            for vdi in vdis:
+                try:
+                    task = yield self._call_xenapi('Async.VDI.destroy', vdi)
+                    yield self._wait_for_task(task)
+                except Exception, exc:
+                    logging.warn(exc)
+        try:
+            task = yield self._call_xenapi('Async.VM.destroy', vm)
+            yield self._wait_for_task(task)
+        except Exception, exc:
+            logging.warn(exc)
+
+    def get_info(self, instance_id):
+        vm = self._lookup_blocking(instance_id)
+        if vm is None:
+            raise Exception('instance not present %s' % instance_id)
+        rec = self._session.xenapi.VM.get_record(vm)
+        return {'state': XENAPI_POWER_STATE[rec['power_state']],
+                'max_mem': long(rec['memory_static_max']) >> 10,
+                'mem': long(rec['memory_dynamic_max']) >> 10,
+                'num_cpu': rec['VCPUs_max'],
+                'cpu_time': 0}
+
+    def get_console_output(self, instance):
+        return 'FAKE CONSOLE OUTPUT'
+
+    @utils.deferredToThread
+    def _lookup(self, i):
+        return self._lookup_blocking(i)
+
+    def _lookup_blocking(self, i):
+        vms = self._session.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)
+        else:
+            return vms[0]
+
+    @utils.deferredToThread
+    def _lookup_vm_vdis(self, vm):
+        return self._lookup_vm_vdis_blocking(vm)
+
+    def _lookup_vm_vdis_blocking(self, vm):
+        # Firstly we get the VBDs, then the VDIs.
+        # TODO: do we leave the read-only devices?
+        vbds = self._session.xenapi.VM.get_VBDs(vm)
+        vdis = []
+        if vbds:
+            for vbd in vbds:
+                try:
+                    vdi = self._session.xenapi.VBD.get_VDI(vbd)
+                    # Test valid VDI
+                    record = self._session.xenapi.VDI.get_record(vdi)
+                except Exception, exc:
+                    logging.warn(exc)
+                else:
+                    vdis.append(vdi)
+            if len(vdis) > 0:
+                return vdis
+            else:
+                return None
+
+    def _wait_for_task(self, task):
+        """Return a Deferred that will give the result of the given task.
+        The task is polled until it completes."""
+        d = defer.Deferred()
+        reactor.callLater(0, self._poll_task, task, d)
+        return d
+
+    @utils.deferredToThread
+    def _poll_task(self, task, deferred):
+        """Poll the given XenAPI task, and fire the given Deferred if we
+        get a result."""
+        try:
+            #logging.debug('Polling task %s...', task)
+            status = self._session.xenapi.task.get_status(task)
+            if status == 'pending':
+                reactor.callLater(FLAGS.xenapi_task_poll_interval,
+                                  self._poll_task, task, deferred)
+            elif status == 'success':
+                result = self._session.xenapi.task.get_result(task)
+                logging.info('Task %s status: success.  %s', task, result)
+                deferred.callback(_parse_xmlrpc_value(result))
+            else:
+                error_info = self._session.xenapi.task.get_error_info(task)
+                logging.warn('Task %s status: %s.  %s', task, status,
+                             error_info)
+                deferred.errback(XenAPI.Failure(error_info))
+            #logging.debug('Polling task %s done.', task)
+        except Exception, exc:
+            logging.warn(exc)
+            deferred.errback(exc)
+
+    @utils.deferredToThread
+    def _call_xenapi(self, method, *args):
+        """Call the specified XenAPI method on a background thread.  Returns
+        a Deferred for the result."""
+        f = self._session.xenapi
+        for m in method.split('.'):
+            f = f.__getattr__(m)
+        return f(*args)
+
+    @utils.deferredToThread
+    def _async_call_plugin(self, plugin, fn, args):
+        """Call Async.host.call_plugin on a background thread.  Returns a
+        Deferred with the task reference."""
+        return _unwrap_plugin_exceptions(
+            self._session.xenapi.Async.host.call_plugin,
+            self._get_xenapi_host(), plugin, fn, args)
+
+    def _get_xenapi_host(self):
+        return self._session.xenapi.session.get_this_host(self._session.handle)
+
+
+def _unwrap_plugin_exceptions(func, *args, **kwargs):
+    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:
+            raise
+    except xmlrpclib.ProtocolError, exc:
+        logging.debug("Got exception: %s", exc)
+        raise
+
+
+def _parse_xmlrpc_value(val):
+    """Parse the given value as if it were an XML-RPC value.  This is
+    sometimes used as the format for the task.result field."""
+    if not val:
+        return val
+    x = xmlrpclib.loads(
+        '<?xml version="1.0"?><methodResponse><params><param>' +
+        val +
+        '</param></params></methodResponse>')
+    return x[0][0]
-- 
cgit 


From 541f8ce212a33d14ac5ba48b3dde6c43a60bc368 Mon Sep 17 00:00:00 2001
From: Armando Migliaccio <armando.migliaccio@citrix.com>
Date: Sat, 27 Nov 2010 13:33:38 +0000
Subject: typos and pep8 fixes

---
 nova/virt/xenapi.py             | 35 ++++++++++++++++++++---------------
 nova/virt/xenapi/power_state.py |  1 -
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/nova/virt/xenapi.py b/nova/virt/xenapi.py
index 93c119205..a17894c84 100644
--- a/nova/virt/xenapi.py
+++ b/nova/virt/xenapi.py
@@ -55,8 +55,8 @@ from twisted.internet import reactor
 from twisted.internet import task
 
 from xenapi import power_state
-from xenapi import vmops
-from xenapi import volumeops
+from xenapi import VMOps
+from xenapi import VolumeOps
 
 XenAPI = None
 
@@ -102,30 +102,32 @@ def get_connection(_):
 
 class XenAPIConnection(object):
     def __init__(self, url, user, pw):
-        self._session = XenAPISession(url, user, pw)
-        self._vmops = VMOps(sef._session)
-        self._volumeops = volumeOps(self._session)
-        
+        session = XenAPISession(url, user, pw)
+        self._vmops = VMOps(session)
+        self._volumeops = VolumeOps(session)
+
     def list_instances(self):
         return self._vmops.list_instances()
-    
+
     def spawn(self, instance):
         self._vmops.spawn(instance)
-    
+
     def reboot(self, instance):
-        self._vmops.reboot(instance)   
+        self._vmops.reboot(instance)
 
     def destroy(self, instance):
         self._vmops.destroy(instance)
-    
+
     def get_info(self, instance_id):
         return self._vmops.get_info(instance_id)
-        
+
     def get_console_output(self, instance):
-        return self._vmops.get_console_output(instance)   
-        
+        return self._vmops.get_console_output(instance)
+
     def attach_volume(self, instance_name, device_path, mountpoint):
-        return self._volumeops.attach_volume(instance_name, device_path, mountpoint)
+        return self._volumeops.attach_volume(instance_name,
+                                               device_path,
+                                               mountpoint)
 
     def detach_volume(self, instance_name, mountpoint):
         return self._volumeops.detach_volume(instance_name, mountpoint)
@@ -136,6 +138,9 @@ class XenAPISession(object):
         self._session = XenAPI.Session(url)
         self._session.login_with_password(user, pw)
 
+    def get_session(self):
+        return self._session
+
     @utils.deferredToThread
     def call_xenapi(self, method, *args):
         """Call the specified XenAPI method on a background thread.  Returns
@@ -162,7 +167,7 @@ class XenAPISession(object):
         d = defer.Deferred()
         reactor.callLater(0, self._poll_task, task, d)
         return d
-        
+
     @utils.deferredToThread
     def _poll_task(self, task, deferred):
         """Poll the given XenAPI task, and fire the given Deferred if we
diff --git a/nova/virt/xenapi/power_state.py b/nova/virt/xenapi/power_state.py
index d2d8fba42..5892f0f48 100644
--- a/nova/virt/xenapi/power_state.py
+++ b/nova/virt/xenapi/power_state.py
@@ -23,4 +23,3 @@ XENAPI_POWER_STATE = {
     'Paused': power_state.PAUSED,
     'Suspended': power_state.SHUTDOWN,  # FIXME
     'Crashed': power_state.CRASHED}
-    
\ No newline at end of file
-- 
cgit 


From b6bed02342ac716b3cb3847fb54b5f285995f3b7 Mon Sep 17 00:00:00 2001
From: Armando Migliaccio <armando.migliaccio@citrix.com>
Date: Sun, 28 Nov 2010 01:49:28 +0000
Subject: further refactoring

---
 nova/virt/xenapi.py               |  15 +-
 nova/virt/xenapi/network_utils.py |  52 +++++
 nova/virt/xenapi/vm_utils.py      | 206 ++++++++++++++++++
 nova/virt/xenapi/vmops.py         | 126 +++++++++++
 nova/virt/xenapi/xenapi.py        | 439 --------------------------------------
 5 files changed, 391 insertions(+), 447 deletions(-)
 create mode 100644 nova/virt/xenapi/network_utils.py
 create mode 100644 nova/virt/xenapi/vm_utils.py
 create mode 100644 nova/virt/xenapi/vmops.py
 delete mode 100644 nova/virt/xenapi/xenapi.py

diff --git a/nova/virt/xenapi.py b/nova/virt/xenapi.py
index a17894c84..2f2cef75e 100644
--- a/nova/virt/xenapi.py
+++ b/nova/virt/xenapi.py
@@ -54,7 +54,6 @@ from twisted.internet import defer
 from twisted.internet import reactor
 from twisted.internet import task
 
-from xenapi import power_state
 from xenapi import VMOps
 from xenapi import VolumeOps
 
@@ -138,8 +137,11 @@ class XenAPISession(object):
         self._session = XenAPI.Session(url)
         self._session.login_with_password(user, pw)
 
-    def get_session(self):
-        return self._session
+    def get_xenapi(self):
+        return self._session.xenapi
+
+    def get_xenapi_host(self):
+        return self._session.xenapi.session.get_this_host(self._session.handle)
 
     @utils.deferredToThread
     def call_xenapi(self, method, *args):
@@ -149,17 +151,14 @@ class XenAPISession(object):
         for m in method.split('.'):
             f = f.__getattr__(m)
         return f(*args)
-
+        
     @utils.deferredToThread
     def async_call_plugin(self, plugin, fn, args):
         """Call Async.host.call_plugin on a background thread.  Returns a
         Deferred with the task reference."""
         return _unwrap_plugin_exceptions(
             self._session.xenapi.Async.host.call_plugin,
-            self._get_xenapi_host(), plugin, fn, args)
-
-    def get_xenapi_host(self):
-        return self._session.xenapi.session.get_this_host(self._session.handle)
+            self.get_xenapi_host(), plugin, fn, args)
 
     def wait_for_task(self, task):
         """Return a Deferred that will give the result of the given task.
diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py
new file mode 100644
index 000000000..e062f916f
--- /dev/null
+++ b/nova/virt/xenapi/network_utils.py
@@ -0,0 +1,52 @@
+# 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 network records and 
+their attributes like bridges, PIFs, QoS, as well as their lookup functions.
+"""
+
+import logging
+import xmlrpclib
+
+from twisted.internet import defer
+from twisted.internet import reactor
+from twisted.internet import task
+
+from nova import db
+from nova import flags
+from nova import process
+from nova import utils
+from nova.auth.manager import AuthManager  # wrap this one
+from nova.compute import instance_types  # wrap this one
+from nova.virt import images   # wrap this one
+
+import power_state
+          
+                
+class NetworkHelper():
+    @classmethod
+    @defer.inlineCallbacks
+    def find_network_with_bridge(self, session, bridge):
+        expr = 'field "bridge" = "%s"' % bridge
+        networks = yield session.call_xenapi('network.get_all_records_where',
+                                           expr)
+        if len(networks) == 1:
+            defer.returnValue(networks.keys()[0])
+        elif len(networks) > 1:
+            raise Exception('Found non-unique network for bridge %s' % bridge)
+        else:
+            raise Exception('Found no network for bridge %s' % bridge)
\ No newline at end of file
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
new file mode 100644
index 000000000..6fb409b26
--- /dev/null
+++ b/nova/virt/xenapi/vm_utils.py
@@ -0,0 +1,206 @@
+# 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 VM records and 
+their attributes like VDIs, VIFs, as well as their lookup functions.
+"""
+
+import logging
+import xmlrpclib
+
+from twisted.internet import defer
+from twisted.internet import reactor
+from twisted.internet import task
+
+from nova import db
+from nova import flags
+from nova import process
+from nova import utils
+from nova.auth.manager import AuthManager  # wrap this one
+from nova.compute import instance_types  # wrap this one
+from nova.virt import images   # wrap this one
+
+import power_state
+          
+                
+class VMHelper():
+    @classmethod
+    @defer.inlineCallbacks
+    def create_vm(self, 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'])
+        rec = {
+            'name_label': instance.name,
+            'name_description': '',
+            'is_a_template': False,
+            'memory_static_min': '0',
+            'memory_static_max': mem,
+            'memory_dynamic_min': mem,
+            'memory_dynamic_max': mem,
+            'VCPUs_at_startup': vcpus,
+            'VCPUs_max': vcpus,
+            'VCPUs_params': {},
+            'actions_after_shutdown': 'destroy',
+            'actions_after_reboot': 'restart',
+            'actions_after_crash': 'destroy',
+            'PV_bootloader': '',
+            'PV_kernel': kernel,
+            'PV_ramdisk': ramdisk,
+            'PV_args': 'root=/dev/xvda1',
+            'PV_bootloader_args': '',
+            'PV_legacy_args': '',
+            'HVM_boot_policy': '',
+            'HVM_boot_params': {},
+            'platform': {},
+            'PCI_bus': '',
+            'recommendations': '',
+            'affinity': '',
+            'user_version': '0',
+            'other_config': {},
+            }
+        logging.debug('Created VM %s...', instance.name)
+        vm_ref = yield session.call_xenapi('VM.create', rec)
+        logging.debug('Created VM %s as %s.', instance.name, vm_ref)
+        defer.returnValue(vm_ref)
+        
+    @classmethod    
+    @defer.inlineCallbacks
+    def create_vbd(self, 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
+        vbd_rec['userdevice'] = str(userdevice)
+        vbd_rec['bootable'] = bootable
+        vbd_rec['mode'] = 'RW'
+        vbd_rec['type'] = 'disk'
+        vbd_rec['unpluggable'] = True
+        vbd_rec['empty'] = False
+        vbd_rec['other_config'] = {}
+        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)
+        vbd_ref = yield session.call_xenapi('VBD.create', vbd_rec)
+        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
+                      vdi_ref)
+        defer.returnValue(vbd_ref)
+
+    @classmethod    
+    @defer.inlineCallbacks
+    def create_vif(self, 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
+        vif_rec['VM'] = vm_ref
+        vif_rec['MAC'] = mac_address
+        vif_rec['MTU'] = '1500'
+        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,
+                      network_ref)
+        vif_ref = yield session.call_xenapi('VIF.create', vif_rec)
+        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
+                      vm_ref, network_ref)
+        defer.returnValue(vif_ref)
+
+    @classmethod
+    @defer.inlineCallbacks
+    def find_network_with_bridge(self, session, bridge):
+        expr = 'field "bridge" = "%s"' % bridge
+        networks = yield session.call_xenapi('network.get_all_records_where',
+                                           expr)
+        if len(networks) == 1:
+            defer.returnValue(networks.keys()[0])
+        elif len(networks) > 1:
+            raise Exception('Found non-unique network for bridge %s' % bridge)
+        else:
+            raise Exception('Found no network for bridge %s' % bridge)
+
+    @classmethod
+    @defer.inlineCallbacks
+    def fetch_image(self, session, image, user, project, use_sr):
+        """use_sr: True to put the image as a VDI in an SR, False to place
+        it on dom0's filesystem.  The former is for VM disks, the latter for
+        its kernel and ramdisk (if external kernels are being used).
+        Returns a Deferred that gives the new VDI UUID."""
+
+        url = images.image_url(image)
+        access = AuthManager().get_access_key(user, project)
+        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
+        args['username'] = access
+        args['password'] = user.secret
+        if use_sr:
+            args['add_partition'] = 'true'
+        task = yield session.async_call_plugin('objectstore', fn, args)
+        uuid = yield session.wait_for_task(task)
+        defer.returnValue(uuid)    
+    
+    @classmethod    
+    @utils.deferredToThread
+    def lookup(self, session, i):
+        return VMHelper.lookup_blocking(i)
+
+    @classmethod
+    def lookup_blocking(self, session, i):
+        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)
+        else:
+            return vms[0]
+
+    @classmethod    
+    @utils.deferredToThread
+    def lookup_vm_vdis(self, session, vm):
+        return VMHelper.lookup_vm_vdis_blocking(session, vm)
+
+    @classmethod
+    def lookup_vm_vdis_blocking(self, session, vm):
+        # Firstly we get the VBDs, then the VDIs.
+        # TODO: do we leave the read-only devices?
+        vbds = session.get_xenapi().VM.get_VBDs(vm)
+        vdis = []
+        if vbds:
+            for vbd in vbds:
+                try:
+                    vdi = session.get_xenapi().VBD.get_VDI(vbd)
+                    # Test valid VDI
+                    record = session.get_xenapi().VDI.get_record(vdi)
+                except Exception, exc:
+                    logging.warn(exc)
+                else:
+                    vdis.append(vdi)
+            if len(vdis) > 0:
+                return vdis
+            else:
+                return None
\ No newline at end of file
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
new file mode 100644
index 000000000..03b7fc614
--- /dev/null
+++ b/nova/virt/xenapi/vmops.py
@@ -0,0 +1,126 @@
+# 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.
+
+"""
+Management class for VM-related functions (spawn, reboot, etc).
+"""
+
+import logging
+import xmlrpclib
+
+from twisted.internet import defer
+from twisted.internet import reactor
+from twisted.internet import task
+
+from nova import db
+from nova import flags
+from nova import process
+from nova import utils
+from nova.auth.manager import AuthManager  # wrap this one
+from nova.compute import instance_types  # wrap this one
+from nova.virt import images   # wrap this one
+
+import power_state
+import VMHelper
+import NetworkHelper
+
+
+class VMOps(object):
+    def __init__(self, session):
+        self._session = session
+    
+    def list_instances(self):
+        return [self._session.get_xenapi().VM.get_name_label(vm) \
+                for vm in self._session.get_xenapi().VM.get_all()]
+
+    @defer.inlineCallbacks
+    def spawn(self, instance):
+        vm = yield VMHelper.lookup(self._session, instance.name)
+        if vm is not None:
+            raise Exception('Attempted to create non-unique name %s' %
+                            instance.name)
+
+        network = db.project_get_network(None, instance.project_id)
+        network_ref = \
+            yield NetworkHelper.find_network_with_bridge(self._session, network.bridge)
+
+        user = AuthManager().get_user(instance.user_id)
+        project = AuthManager().get_project(instance.project_id)
+        vdi_uuid = yield VMHelper.fetch_image(self._session,
+            instance.image_id, user, project, True)
+        kernel = yield VMHelper.fetch_image(self._session,
+            instance.kernel_id, user, project, False)
+        ramdisk = yield VMHelper.fetch_image(self._session,
+            instance.ramdisk_id, user, project, False)
+        vdi_ref = yield self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
+
+        vm_ref = yield VMHelper.create_vm(self._session, instance, kernel, ramdisk)
+        yield VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
+        if network_ref:
+            yield VMHelper.create_vif(self._session, vm_ref, network_ref, instance.mac_address)
+        logging.debug('Starting VM %s...', vm_ref)
+        yield self._session.call_xenapi('VM.start', vm_ref, False, False)
+        logging.info('Spawning VM %s created %s.', instance.name, vm_ref)
+
+    @defer.inlineCallbacks
+    def reboot(self, instance):
+        vm = yield VMHelper.lookup(self._session, instance.name)
+        if vm is None:
+            raise Exception('instance not present %s' % instance.name)
+        task = yield self._session.call_xenapi('Async.VM.clean_reboot', vm)
+        yield self._session.wait_for_task(task)
+
+    @defer.inlineCallbacks
+    def destroy(self, instance):
+        vm = yield VMHelper.lookup(self._session, instance.name)
+        if vm is None:
+            # Don't complain, just return.  This lets us clean up instances
+            # that have already disappeared from the underlying platform.
+            defer.returnValue(None)
+        # Get the VDIs related to the VM
+        vdis = yield VMHelper.lookup_vm_vdis(self._session, vm)
+        try:
+            task = yield self._session.call_xenapi('Async.VM.hard_shutdown', vm)
+            yield self._session.wait_for_task(task)
+        except Exception, exc:
+            logging.warn(exc)
+        # Disk clean-up
+        if vdis:
+            for vdi in vdis:
+                try:
+                    task = yield self._session.call_xenapi('Async.VDI.destroy', vdi)
+                    yield self._session.wait_for_task(task)
+                except Exception, exc:
+                    logging.warn(exc)
+        try:
+            task = yield self._session.call_xenapi('Async.VM.destroy', vm)
+            yield self._session.wait_for_task(task)
+        except Exception, exc:
+            logging.warn(exc)
+
+    def get_info(self, instance_id):
+        vm = VMHelper.lookup_blocking(self._session, instance_id)
+        if vm is None:
+            raise Exception('instance not present %s' % instance_id)
+        rec = self._session.get_xenapi().VM.get_record(vm)
+        return {'state': XENAPI_POWER_STATE[rec['power_state']],
+                'max_mem': long(rec['memory_static_max']) >> 10,
+                'mem': long(rec['memory_dynamic_max']) >> 10,
+                'num_cpu': rec['VCPUs_max'],
+                'cpu_time': 0}
+
+    def get_console_output(self, instance):
+        return 'FAKE CONSOLE OUTPUT'
\ No newline at end of file
diff --git a/nova/virt/xenapi/xenapi.py b/nova/virt/xenapi/xenapi.py
deleted file mode 100644
index ddbef4303..000000000
--- a/nova/virt/xenapi/xenapi.py
+++ /dev/null
@@ -1,439 +0,0 @@
-# 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.
-
-"""
-A connection to XenServer or Xen Cloud Platform.
-
-The concurrency model for this class is as follows:
-
-All XenAPI calls are on a thread (using t.i.t.deferToThread, via the decorator
-deferredToThread).  They are remote calls, and so may hang for the usual
-reasons.  They should not be allowed to block the reactor thread.
-
-All long-running XenAPI calls (VM.start, VM.reboot, etc) are called async
-(using XenAPI.VM.async_start etc).  These return a task, which can then be
-polled for completion.  Polling is handled using reactor.callLater.
-
-This combination of techniques means that we don't block the reactor thread at
-all, and at the same time we don't hold lots of threads waiting for
-long-running operations.
-
-FIXME: get_info currently doesn't conform to these rules, and will block the
-reactor thread if the VM.get_by_name_label or VM.get_record calls block.
-
-**Related Flags**
-
-:xenapi_connection_url:  URL for connection to XenServer/Xen Cloud Platform.
-:xenapi_connection_username:  Username for connection to XenServer/Xen Cloud
-                              Platform (default: root).
-:xenapi_connection_password:  Password for connection to XenServer/Xen Cloud
-                              Platform.
-:xenapi_task_poll_interval:  The interval (seconds) used for polling of
-                             remote tasks (Async.VM.start, etc)
-                             (default: 0.5).
-
-"""
-
-import logging
-import xmlrpclib
-
-from twisted.internet import defer
-from twisted.internet import reactor
-from twisted.internet import task
-
-from nova import db
-from nova import flags
-from nova import process
-from nova import utils
-from nova.auth.manager import AuthManager  # wrap this one
-from nova.compute import instance_types  # wrap this one
-from xenapi import power_state
-from nova.virt import images   # wrap this one
-
-XenAPI = None
-
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('xenapi_connection_url',
-                    None,
-                    'URL for connection to XenServer/Xen Cloud Platform.'
-                    ' Required if connection_type=xenapi.')
-flags.DEFINE_string('xenapi_connection_username',
-                    'root',
-                    'Username for connection to XenServer/Xen Cloud Platform.'
-                    ' Used only if connection_type=xenapi.')
-flags.DEFINE_string('xenapi_connection_password',
-                    None,
-                    'Password for connection to XenServer/Xen Cloud Platform.'
-                    ' Used only if connection_type=xenapi.')
-flags.DEFINE_float('xenapi_task_poll_interval',
-                   0.5,
-                   'The interval used for polling of remote tasks '
-                   '(Async.VM.start, etc).  Used only if '
-                   'connection_type=xenapi.')
-
-
-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
-    if not url or password is None:
-        raise Exception('Must specify xenapi_connection_url, '
-                        'xenapi_connection_username (optionally), and '
-                        'xenapi_connection_password to use '
-                        'connection_type=xenapi')
-    return XenAPIConnection(url, username, password)
-
-
-class XenAPISession(object):
-    def __init__(self, url, user, pw):
-        self._session = XenAPI.Session(url)
-        self._session.login_with_password(user, pw)
-        
-    def session(self):
-    return self._session
-    
-    def list_instances(self):
-        return [self._session.xenapi.VM.get_name_label(vm) \
-                for vm in self._session.xenapi.VM.get_all()]
-
-    @defer.inlineCallbacks
-    def spawn(self, instance):
-        vm = yield self._lookup(instance.name)
-        if vm is not None:
-            raise Exception('Attempted to create non-unique name %s' %
-                            instance.name)
-
-        network = db.project_get_network(None, instance.project_id)
-        network_ref = \
-            yield self._find_network_with_bridge(network.bridge)
-
-        user = AuthManager().get_user(instance.user_id)
-        project = AuthManager().get_project(instance.project_id)
-        vdi_uuid = yield self._fetch_image(
-            instance.image_id, user, project, True)
-        kernel = yield self._fetch_image(
-            instance.kernel_id, user, project, False)
-        ramdisk = yield self._fetch_image(
-            instance.ramdisk_id, user, project, False)
-        vdi_ref = yield self._call_xenapi('VDI.get_by_uuid', vdi_uuid)
-
-        vm_ref = yield self._create_vm(instance, kernel, ramdisk)
-        yield self._create_vbd(vm_ref, vdi_ref, 0, True)
-        if network_ref:
-            yield self._create_vif(vm_ref, network_ref, instance.mac_address)
-        logging.debug('Starting VM %s...', vm_ref)
-        yield self._call_xenapi('VM.start', vm_ref, False, False)
-        logging.info('Spawning VM %s created %s.', instance.name, vm_ref)
-
-    @defer.inlineCallbacks
-    def _create_vm(self, 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'])
-        rec = {
-            'name_label': instance.name,
-            'name_description': '',
-            'is_a_template': False,
-            'memory_static_min': '0',
-            'memory_static_max': mem,
-            'memory_dynamic_min': mem,
-            'memory_dynamic_max': mem,
-            'VCPUs_at_startup': vcpus,
-            'VCPUs_max': vcpus,
-            'VCPUs_params': {},
-            'actions_after_shutdown': 'destroy',
-            'actions_after_reboot': 'restart',
-            'actions_after_crash': 'destroy',
-            'PV_bootloader': '',
-            'PV_kernel': kernel,
-            'PV_ramdisk': ramdisk,
-            'PV_args': 'root=/dev/xvda1',
-            'PV_bootloader_args': '',
-            'PV_legacy_args': '',
-            'HVM_boot_policy': '',
-            'HVM_boot_params': {},
-            'platform': {},
-            'PCI_bus': '',
-            'recommendations': '',
-            'affinity': '',
-            'user_version': '0',
-            'other_config': {},
-            }
-        logging.debug('Created VM %s...', instance.name)
-        vm_ref = yield self._call_xenapi('VM.create', rec)
-        logging.debug('Created VM %s as %s.', instance.name, vm_ref)
-        defer.returnValue(vm_ref)
-
-    @defer.inlineCallbacks
-    def _create_vbd(self, 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
-        vbd_rec['userdevice'] = str(userdevice)
-        vbd_rec['bootable'] = bootable
-        vbd_rec['mode'] = 'RW'
-        vbd_rec['type'] = 'disk'
-        vbd_rec['unpluggable'] = True
-        vbd_rec['empty'] = False
-        vbd_rec['other_config'] = {}
-        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)
-        vbd_ref = yield self._call_xenapi('VBD.create', vbd_rec)
-        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
-                      vdi_ref)
-        defer.returnValue(vbd_ref)
-
-    @defer.inlineCallbacks
-    def _create_vif(self, 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
-        vif_rec['VM'] = vm_ref
-        vif_rec['MAC'] = mac_address
-        vif_rec['MTU'] = '1500'
-        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,
-                      network_ref)
-        vif_ref = yield self._call_xenapi('VIF.create', vif_rec)
-        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
-                      vm_ref, network_ref)
-        defer.returnValue(vif_ref)
-
-    @defer.inlineCallbacks
-    def _find_network_with_bridge(self, bridge):
-        expr = 'field "bridge" = "%s"' % bridge
-        networks = yield self._call_xenapi('network.get_all_records_where',
-                                           expr)
-        if len(networks) == 1:
-            defer.returnValue(networks.keys()[0])
-        elif len(networks) > 1:
-            raise Exception('Found non-unique network for bridge %s' % bridge)
-        else:
-            raise Exception('Found no network for bridge %s' % bridge)
-
-    @defer.inlineCallbacks
-    def _fetch_image(self, image, user, project, use_sr):
-        """use_sr: True to put the image as a VDI in an SR, False to place
-        it on dom0's filesystem.  The former is for VM disks, the latter for
-        its kernel and ramdisk (if external kernels are being used).
-        Returns a Deferred that gives the new VDI UUID."""
-
-        url = images.image_url(image)
-        access = AuthManager().get_access_key(user, project)
-        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
-        args['username'] = access
-        args['password'] = user.secret
-        if use_sr:
-            args['add_partition'] = 'true'
-        task = yield self._async_call_plugin('objectstore', fn, args)
-        uuid = yield self._wait_for_task(task)
-        defer.returnValue(uuid)
-
-    @defer.inlineCallbacks
-    def reboot(self, instance):
-        vm = yield self._lookup(instance.name)
-        if vm is None:
-            raise Exception('instance not present %s' % instance.name)
-        task = yield self._call_xenapi('Async.VM.clean_reboot', vm)
-        yield self._wait_for_task(task)
-
-    @defer.inlineCallbacks
-    def destroy(self, instance):
-        vm = yield self._lookup(instance.name)
-        if vm is None:
-            # Don't complain, just return.  This lets us clean up instances
-            # that have already disappeared from the underlying platform.
-            defer.returnValue(None)
-        # Get the VDIs related to the VM
-        vdis = yield self._lookup_vm_vdis(vm)
-        try:
-            task = yield self._call_xenapi('Async.VM.hard_shutdown', vm)
-            yield self._wait_for_task(task)
-        except Exception, exc:
-            logging.warn(exc)
-        # Disk clean-up
-        if vdis:
-            for vdi in vdis:
-                try:
-                    task = yield self._call_xenapi('Async.VDI.destroy', vdi)
-                    yield self._wait_for_task(task)
-                except Exception, exc:
-                    logging.warn(exc)
-        try:
-            task = yield self._call_xenapi('Async.VM.destroy', vm)
-            yield self._wait_for_task(task)
-        except Exception, exc:
-            logging.warn(exc)
-
-    def get_info(self, instance_id):
-        vm = self._lookup_blocking(instance_id)
-        if vm is None:
-            raise Exception('instance not present %s' % instance_id)
-        rec = self._session.xenapi.VM.get_record(vm)
-        return {'state': XENAPI_POWER_STATE[rec['power_state']],
-                'max_mem': long(rec['memory_static_max']) >> 10,
-                'mem': long(rec['memory_dynamic_max']) >> 10,
-                'num_cpu': rec['VCPUs_max'],
-                'cpu_time': 0}
-
-    def get_console_output(self, instance):
-        return 'FAKE CONSOLE OUTPUT'
-
-    @utils.deferredToThread
-    def _lookup(self, i):
-        return self._lookup_blocking(i)
-
-    def _lookup_blocking(self, i):
-        vms = self._session.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)
-        else:
-            return vms[0]
-
-    @utils.deferredToThread
-    def _lookup_vm_vdis(self, vm):
-        return self._lookup_vm_vdis_blocking(vm)
-
-    def _lookup_vm_vdis_blocking(self, vm):
-        # Firstly we get the VBDs, then the VDIs.
-        # TODO: do we leave the read-only devices?
-        vbds = self._session.xenapi.VM.get_VBDs(vm)
-        vdis = []
-        if vbds:
-            for vbd in vbds:
-                try:
-                    vdi = self._session.xenapi.VBD.get_VDI(vbd)
-                    # Test valid VDI
-                    record = self._session.xenapi.VDI.get_record(vdi)
-                except Exception, exc:
-                    logging.warn(exc)
-                else:
-                    vdis.append(vdi)
-            if len(vdis) > 0:
-                return vdis
-            else:
-                return None
-
-    def _wait_for_task(self, task):
-        """Return a Deferred that will give the result of the given task.
-        The task is polled until it completes."""
-        d = defer.Deferred()
-        reactor.callLater(0, self._poll_task, task, d)
-        return d
-
-    @utils.deferredToThread
-    def _poll_task(self, task, deferred):
-        """Poll the given XenAPI task, and fire the given Deferred if we
-        get a result."""
-        try:
-            #logging.debug('Polling task %s...', task)
-            status = self._session.xenapi.task.get_status(task)
-            if status == 'pending':
-                reactor.callLater(FLAGS.xenapi_task_poll_interval,
-                                  self._poll_task, task, deferred)
-            elif status == 'success':
-                result = self._session.xenapi.task.get_result(task)
-                logging.info('Task %s status: success.  %s', task, result)
-                deferred.callback(_parse_xmlrpc_value(result))
-            else:
-                error_info = self._session.xenapi.task.get_error_info(task)
-                logging.warn('Task %s status: %s.  %s', task, status,
-                             error_info)
-                deferred.errback(XenAPI.Failure(error_info))
-            #logging.debug('Polling task %s done.', task)
-        except Exception, exc:
-            logging.warn(exc)
-            deferred.errback(exc)
-
-    @utils.deferredToThread
-    def _call_xenapi(self, method, *args):
-        """Call the specified XenAPI method on a background thread.  Returns
-        a Deferred for the result."""
-        f = self._session.xenapi
-        for m in method.split('.'):
-            f = f.__getattr__(m)
-        return f(*args)
-
-    @utils.deferredToThread
-    def _async_call_plugin(self, plugin, fn, args):
-        """Call Async.host.call_plugin on a background thread.  Returns a
-        Deferred with the task reference."""
-        return _unwrap_plugin_exceptions(
-            self._session.xenapi.Async.host.call_plugin,
-            self._get_xenapi_host(), plugin, fn, args)
-
-    def _get_xenapi_host(self):
-        return self._session.xenapi.session.get_this_host(self._session.handle)
-
-
-def _unwrap_plugin_exceptions(func, *args, **kwargs):
-    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:
-            raise
-    except xmlrpclib.ProtocolError, exc:
-        logging.debug("Got exception: %s", exc)
-        raise
-
-
-def _parse_xmlrpc_value(val):
-    """Parse the given value as if it were an XML-RPC value.  This is
-    sometimes used as the format for the task.result field."""
-    if not val:
-        return val
-    x = xmlrpclib.loads(
-        '<?xml version="1.0"?><methodResponse><params><param>' +
-        val +
-        '</param></params></methodResponse>')
-    return x[0][0]
-- 
cgit 


From c10a6f3e97a5871ac0cdce97bde89b3cee59d336 Mon Sep 17 00:00:00 2001
From: Armando Migliaccio <armando.migliaccio@citrix.com>
Date: Sun, 28 Nov 2010 15:12:37 +0000
Subject: other round of refactoring

---
 nova/virt/xenapi/novadeps.py    | 97 +++++++++++++++++++++++++++++++++++++++++
 nova/virt/xenapi/power_state.py | 25 -----------
 nova/virt/xenapi/vm_utils.py    | 32 ++++----------
 nova/virt/xenapi/vmops.py       | 43 +++++++++---------
 nova/virt/xenapi/volumeops.py   | 35 +++++++++++++++
 5 files changed, 161 insertions(+), 71 deletions(-)
 create mode 100644 nova/virt/xenapi/novadeps.py
 delete mode 100644 nova/virt/xenapi/power_state.py
 create mode 100644 nova/virt/xenapi/volumeops.py

diff --git a/nova/virt/xenapi/novadeps.py b/nova/virt/xenapi/novadeps.py
new file mode 100644
index 000000000..a4e512263
--- /dev/null
+++ b/nova/virt/xenapi/novadeps.py
@@ -0,0 +1,97 @@
+# 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.
+
+from nova import db
+from nova import flags
+from nova import process
+from nova import utils
+
+from nova.compute import power_state
+from nova.auth.manager import AuthManager
+from nova.compute import instance_types
+from nova.virt import images   
+
+XENAPI_POWER_STATE = {
+    'Halted': power_state.SHUTDOWN,
+    'Running': power_state.RUNNING,
+    'Paused': power_state.PAUSED,
+    'Suspended': power_state.SHUTDOWN,  # FIXME
+    'Crashed': power_state.CRASHED}
+    
+class Instance(object):
+
+    @classmethod
+    def get_name(self, instance):
+        return instance.name
+        
+    @classmethod
+    def get_type(self, instance):
+        return instance_types.INSTANCE_TYPES[instance.instance_type]
+ 
+    @classmethod
+    def get_project(self, instance):
+        return AuthManager().get_project(instance.project_id)
+            
+    @classmethod
+    def get_project_id(self, instance):
+        return instance.project_id
+                            
+    @classmethod
+    def get_image_id(self, instance):
+        return instance.image_id
+        
+    @classmethod
+    def get_kernel_id(self, instance):
+        return instance.kernel_id
+                    
+    @classmethod
+    def get_ramdisk_id(self, instance):
+        return instance.ramdisk_id
+
+    @classmethod
+    def get_network(self, instance):
+        return db.project_get_network(None, instance.project_id)
+    
+    @classmethod
+    def get_mac(self, instance):
+        return instance.mac_address
+    
+    @classmethod
+    def get_user(self, instance):
+        return AuthManager().get_user(instance.user_id)
+        
+
+class Network(object):
+
+    @classmethod
+    def get_bridge(self, network):
+        return network.bridge
+        
+class Image(object):
+
+    @classmethod
+    def get_url(self, image):
+        return images.image_url(image)
+        
+class User(object):
+
+    @classmethod
+    def get_access(self, user, project):
+        return AuthManager().get_access_key(user, project)
+
+    @classmethod
+    def get_secret(self, user):
+        return user.secret
\ No newline at end of file
diff --git a/nova/virt/xenapi/power_state.py b/nova/virt/xenapi/power_state.py
deleted file mode 100644
index 5892f0f48..000000000
--- a/nova/virt/xenapi/power_state.py
+++ /dev/null
@@ -1,25 +0,0 @@
-# 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.
-
-from nova.compute import power_state
-
-
-XENAPI_POWER_STATE = {
-    'Halted': power_state.SHUTDOWN,
-    'Running': power_state.RUNNING,
-    'Paused': power_state.PAUSED,
-    'Suspended': power_state.SHUTDOWN,  # FIXME
-    'Crashed': power_state.CRASHED}
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index 6fb409b26..8329f0d7e 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -30,11 +30,10 @@ from nova import db
 from nova import flags
 from nova import process
 from nova import utils
-from nova.auth.manager import AuthManager  # wrap this one
-from nova.compute import instance_types  # wrap this one
-from nova.virt import images   # wrap this one
 
-import power_state
+from novadeps import Instance
+from novadeps import Image
+from novadeps import User
           
                 
 class VMHelper():
@@ -44,7 +43,7 @@ class VMHelper():
         """Create a VM record.  Returns a Deferred that gives the new
         VM reference."""
 
-        instance_type = instance_types.INSTANCE_TYPES[instance.instance_type]
+        instance_type = Instance.get_type(instance) 
         mem = str(long(instance_type['memory_mb']) * 1024 * 1024)
         vcpus = str(instance_type['vcpus'])
         rec = {
@@ -76,9 +75,9 @@ class VMHelper():
             'user_version': '0',
             'other_config': {},
             }
-        logging.debug('Created VM %s...', instance.name)
+        logging.debug('Created VM %s...', Instance.get_name(instance))
         vm_ref = yield 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.get_name(instance), vm_ref)
         defer.returnValue(vm_ref)
         
     @classmethod    
@@ -128,19 +127,6 @@ class VMHelper():
                       vm_ref, network_ref)
         defer.returnValue(vif_ref)
 
-    @classmethod
-    @defer.inlineCallbacks
-    def find_network_with_bridge(self, session, bridge):
-        expr = 'field "bridge" = "%s"' % bridge
-        networks = yield session.call_xenapi('network.get_all_records_where',
-                                           expr)
-        if len(networks) == 1:
-            defer.returnValue(networks.keys()[0])
-        elif len(networks) > 1:
-            raise Exception('Found non-unique network for bridge %s' % bridge)
-        else:
-            raise Exception('Found no network for bridge %s' % bridge)
-
     @classmethod
     @defer.inlineCallbacks
     def fetch_image(self, session, image, user, project, use_sr):
@@ -149,14 +135,14 @@ class VMHelper():
         its kernel and ramdisk (if external kernels are being used).
         Returns a Deferred that gives the new VDI UUID."""
 
-        url = images.image_url(image)
-        access = AuthManager().get_access_key(user, project)
+        url = Image.get_url(image)
+        access = User.get_access(user, project)
         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
         args['username'] = access
-        args['password'] = user.secret
+        args['password'] = User.get_secret(user)
         if use_sr:
             args['add_partition'] = 'true'
         task = yield session.async_call_plugin('objectstore', fn, args)
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 03b7fc614..abb422502 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -25,18 +25,14 @@ from twisted.internet import defer
 from twisted.internet import reactor
 from twisted.internet import task
 
-from nova import db
-from nova import flags
-from nova import process
-from nova import utils
-from nova.auth.manager import AuthManager  # wrap this one
-from nova.compute import instance_types  # wrap this one
-from nova.virt import images   # wrap this one
-
-import power_state
+
 import VMHelper
 import NetworkHelper
 
+from novadeps import XENAPI_POWER_STATE
+from novadeps import Auth
+from novadeps import Instance
+from novadeps import Network
 
 class VMOps(object):
     def __init__(self, session):
@@ -48,44 +44,45 @@ class VMOps(object):
 
     @defer.inlineCallbacks
     def spawn(self, instance):
-        vm = yield VMHelper.lookup(self._session, instance.name)
+        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
         if vm is not None:
             raise Exception('Attempted to create non-unique name %s' %
-                            instance.name)
+                            Instance.get_name(instance))
 
-        network = db.project_get_network(None, instance.project_id)
+        network = Instance.get_network(instance)
         network_ref = \
-            yield NetworkHelper.find_network_with_bridge(self._session, network.bridge)
+            yield NetworkHelper.find_network_with_bridge(self._session, Network.get_bridge(network))
 
-        user = AuthManager().get_user(instance.user_id)
-        project = AuthManager().get_project(instance.project_id)
+        user = Instance.get_user(instance)
+        project = Instance.get_project(instance)
         vdi_uuid = yield VMHelper.fetch_image(self._session,
-            instance.image_id, user, project, True)
+            Instance.get_image_id(instance), user, project, True)
         kernel = yield VMHelper.fetch_image(self._session,
-            instance.kernel_id, user, project, False)
+            Instance.get_kernel_id(instance), user, project, False)
         ramdisk = yield VMHelper.fetch_image(self._session,
-            instance.ramdisk_id, user, project, False)
+            Instance.get_ramdisk_id(instance), user, project, False)
         vdi_ref = yield self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
 
         vm_ref = yield VMHelper.create_vm(self._session, instance, kernel, ramdisk)
         yield VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
         if network_ref:
-            yield VMHelper.create_vif(self._session, vm_ref, network_ref, instance.mac_address)
+            yield VMHelper.create_vif(self._session, vm_ref, network_ref, Instance.get_mac(instance))
         logging.debug('Starting VM %s...', vm_ref)
         yield self._session.call_xenapi('VM.start', vm_ref, False, False)
-        logging.info('Spawning VM %s created %s.', instance.name, vm_ref)
+        logging.info('Spawning VM %s created %s.', Instance.get_name(instance), vm_ref)
 
     @defer.inlineCallbacks
     def reboot(self, instance):
-        vm = yield VMHelper.lookup(self._session, instance.name)
+        instance_name = Instance.get_name(instance)
+        vm = yield VMHelper.lookup(self._session, instance_name)
         if vm is None:
-            raise Exception('instance not present %s' % instance.name)
+            raise Exception('instance not present %s' % instance_name)
         task = yield self._session.call_xenapi('Async.VM.clean_reboot', vm)
         yield self._session.wait_for_task(task)
 
     @defer.inlineCallbacks
     def destroy(self, instance):
-        vm = yield VMHelper.lookup(self._session, instance.name)
+        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
         if vm is None:
             # Don't complain, just return.  This lets us clean up instances
             # that have already disappeared from the underlying platform.
diff --git a/nova/virt/xenapi/volumeops.py b/nova/virt/xenapi/volumeops.py
new file mode 100644
index 000000000..f5b43adfb
--- /dev/null
+++ b/nova/virt/xenapi/volumeops.py
@@ -0,0 +1,35 @@
+# 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.
+
+"""
+Management class for Storage-related functions (attach, detach, etc).
+"""
+
+from twisted.internet import defer
+
+from nova import exception
+from nova.compute import power_state
+
+
+class VMOps(object):
+    def __init__(self, session):
+        self._session = session
+
+    def attach_volume(self, instance_name, device_path, mountpoint):
+        return True
+
+    def detach_volume(self, instance_name, mountpoint):
+        return True
\ No newline at end of file
-- 
cgit 


From 9d26ad69bfeb88106a08f0f3f1e15ed621c18af2 Mon Sep 17 00:00:00 2001
From: Armando Migliaccio <armando.migliaccio@citrix.com>
Date: Mon, 29 Nov 2010 10:25:52 +0000
Subject: first cut of the refactoring of the XenAPIConnection class. Currently
 the class merged both the code for managing the XenAPI connection and the
 business logic for implementing Nova operations. If left like this, it would
 eventually become difficult to read, maintain and extend. The file was
 getting kind of big and cluttered, so a quick refactoring now will save a lot
 of headaches later

---
 nova/virt/xenapi/network_utils.py | 10 ----------
 nova/virt/xenapi/vm_utils.py      |  2 +-
 nova/virt/xenapi/vmops.py         |  1 -
 nova/virt/xenapi/volumeops.py     |  5 -----
 4 files changed, 1 insertion(+), 17 deletions(-)

diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py
index e062f916f..83ade1389 100644
--- a/nova/virt/xenapi/network_utils.py
+++ b/nova/virt/xenapi/network_utils.py
@@ -25,16 +25,6 @@ import xmlrpclib
 from twisted.internet import defer
 from twisted.internet import reactor
 from twisted.internet import task
-
-from nova import db
-from nova import flags
-from nova import process
-from nova import utils
-from nova.auth.manager import AuthManager  # wrap this one
-from nova.compute import instance_types  # wrap this one
-from nova.virt import images   # wrap this one
-
-import power_state
           
                 
 class NetworkHelper():
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index 8329f0d7e..a1b444e41 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -152,7 +152,7 @@ class VMHelper():
     @classmethod    
     @utils.deferredToThread
     def lookup(self, session, i):
-        return VMHelper.lookup_blocking(i)
+        return VMHelper.lookup_blocking(session, i)
 
     @classmethod
     def lookup_blocking(self, session, i):
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index abb422502..c04a9f4ec 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -25,7 +25,6 @@ from twisted.internet import defer
 from twisted.internet import reactor
 from twisted.internet import task
 
-
 import VMHelper
 import NetworkHelper
 
diff --git a/nova/virt/xenapi/volumeops.py b/nova/virt/xenapi/volumeops.py
index f5b43adfb..fd316a0b8 100644
--- a/nova/virt/xenapi/volumeops.py
+++ b/nova/virt/xenapi/volumeops.py
@@ -18,11 +18,6 @@
 Management class for Storage-related functions (attach, detach, etc).
 """
 
-from twisted.internet import defer
-
-from nova import exception
-from nova.compute import power_state
-
 
 class VMOps(object):
     def __init__(self, session):
-- 
cgit 


From 9e34c9c7dc88d9e361c7f2d05e06b53ff68ee53f Mon Sep 17 00:00:00 2001
From: Armando Migliaccio <armando.migliaccio@citrix.com>
Date: Mon, 29 Nov 2010 12:52:03 +0000
Subject: fixed deps

---
 nova/virt/xapi/__init__.py        |  15 +++
 nova/virt/xapi/network_utils.py   |  40 ++++++++
 nova/virt/xapi/novadeps.py        | 100 ++++++++++++++++++++
 nova/virt/xapi/vm_utils.py        | 190 +++++++++++++++++++++++++++++++++++++
 nova/virt/xapi/vmops.py           | 123 ++++++++++++++++++++++++
 nova/virt/xapi/volumeops.py       |  30 ++++++
 nova/virt/xenapi.py               |  11 ++-
 nova/virt/xenapi/network_utils.py |  42 ---------
 nova/virt/xenapi/novadeps.py      |  97 -------------------
 nova/virt/xenapi/vm_utils.py      | 192 --------------------------------------
 nova/virt/xenapi/vmops.py         | 122 ------------------------
 nova/virt/xenapi/volumeops.py     |  30 ------
 12 files changed, 505 insertions(+), 487 deletions(-)
 create mode 100644 nova/virt/xapi/__init__.py
 create mode 100644 nova/virt/xapi/network_utils.py
 create mode 100644 nova/virt/xapi/novadeps.py
 create mode 100644 nova/virt/xapi/vm_utils.py
 create mode 100644 nova/virt/xapi/vmops.py
 create mode 100644 nova/virt/xapi/volumeops.py
 delete mode 100644 nova/virt/xenapi/network_utils.py
 delete mode 100644 nova/virt/xenapi/novadeps.py
 delete mode 100644 nova/virt/xenapi/vm_utils.py
 delete mode 100644 nova/virt/xenapi/vmops.py
 delete mode 100644 nova/virt/xenapi/volumeops.py

diff --git a/nova/virt/xapi/__init__.py b/nova/virt/xapi/__init__.py
new file mode 100644
index 000000000..3d598c463
--- /dev/null
+++ b/nova/virt/xapi/__init__.py
@@ -0,0 +1,15 @@
+# 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.
diff --git a/nova/virt/xapi/network_utils.py b/nova/virt/xapi/network_utils.py
new file mode 100644
index 000000000..b58b9159c
--- /dev/null
+++ b/nova/virt/xapi/network_utils.py
@@ -0,0 +1,40 @@
+# 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 network records and
+their attributes like bridges, PIFs, QoS, as well as their lookup functions.
+"""
+
+from twisted.internet import defer
+
+
+class NetworkHelper():
+    def __init__(self, session):
+        return
+
+    @classmethod
+    @defer.inlineCallbacks
+    def find_network_with_bridge(self, session, bridge):
+        expr = 'field "bridge" = "%s"' % bridge
+        networks = yield session.call_xenapi('network.get_all_records_where',
+                                           expr)
+        if len(networks) == 1:
+            defer.returnValue(networks.keys()[0])
+        elif len(networks) > 1:
+            raise Exception('Found non-unique network for bridge %s' % bridge)
+        else:
+            raise Exception('Found no network for bridge %s' % bridge)
diff --git a/nova/virt/xapi/novadeps.py b/nova/virt/xapi/novadeps.py
new file mode 100644
index 000000000..8cb5e3246
--- /dev/null
+++ b/nova/virt/xapi/novadeps.py
@@ -0,0 +1,100 @@
+# 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.
+
+from nova import db
+from nova import flags
+from nova import process
+from nova import utils
+
+from nova.compute import power_state
+from nova.auth.manager import AuthManager
+from nova.compute import instance_types
+from nova.virt import images
+
+XENAPI_POWER_STATE = {
+    'Halted': power_state.SHUTDOWN,
+    'Running': power_state.RUNNING,
+    'Paused': power_state.PAUSED,
+    'Suspended': power_state.SHUTDOWN,  # FIXME
+    'Crashed': power_state.CRASHED}
+
+
+class Instance(object):
+
+    @classmethod
+    def get_name(self, instance):
+        return instance.name
+
+    @classmethod
+    def get_type(self, instance):
+        return instance_types.INSTANCE_TYPES[instance.instance_type]
+
+    @classmethod
+    def get_project(self, instance):
+        return AuthManager().get_project(instance.project_id)
+
+    @classmethod
+    def get_project_id(self, instance):
+        return instance.project_id
+
+    @classmethod
+    def get_image_id(self, instance):
+        return instance.image_id
+
+    @classmethod
+    def get_kernel_id(self, instance):
+        return instance.kernel_id
+
+    @classmethod
+    def get_ramdisk_id(self, instance):
+        return instance.ramdisk_id
+
+    @classmethod
+    def get_network(self, instance):
+        return db.project_get_network(None, instance.project_id)
+
+    @classmethod
+    def get_mac(self, instance):
+        return instance.mac_address
+
+    @classmethod
+    def get_user(self, instance):
+        return AuthManager().get_user(instance.user_id)
+
+
+class Network(object):
+
+    @classmethod
+    def get_bridge(self, network):
+        return network.bridge
+
+
+class Image(object):
+
+    @classmethod
+    def get_url(self, image):
+        return images.image_url(image)
+
+
+class User(object):
+
+    @classmethod
+    def get_access(self, user, project):
+        return AuthManager().get_access_key(user, project)
+
+    @classmethod
+    def get_secret(self, user):
+        return user.secret
diff --git a/nova/virt/xapi/vm_utils.py b/nova/virt/xapi/vm_utils.py
new file mode 100644
index 000000000..41f687ccb
--- /dev/null
+++ b/nova/virt/xapi/vm_utils.py
@@ -0,0 +1,190 @@
+# 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 VM records and
+their attributes like VDIs, VIFs, as well as their lookup functions.
+"""
+
+import logging
+
+from twisted.internet import defer
+
+from nova import utils
+
+from novadeps import Instance
+from novadeps import Image
+from novadeps import User
+
+
+class VMHelper():
+    def __init__(self, session):
+        return
+    
+    @classmethod
+    @defer.inlineCallbacks
+    def create_vm(self, session, instance, kernel, ramdisk):
+        """Create a VM record.  Returns a Deferred that gives the new
+        VM reference."""
+
+        instance_type = Instance.get_type(instance)
+        mem = str(long(instance_type['memory_mb']) * 1024 * 1024)
+        vcpus = str(instance_type['vcpus'])
+        rec = {
+            'name_label': instance.name,
+            'name_description': '',
+            'is_a_template': False,
+            'memory_static_min': '0',
+            'memory_static_max': mem,
+            'memory_dynamic_min': mem,
+            'memory_dynamic_max': mem,
+            'VCPUs_at_startup': vcpus,
+            'VCPUs_max': vcpus,
+            'VCPUs_params': {},
+            'actions_after_shutdown': 'destroy',
+            'actions_after_reboot': 'restart',
+            'actions_after_crash': 'destroy',
+            'PV_bootloader': '',
+            'PV_kernel': kernel,
+            'PV_ramdisk': ramdisk,
+            'PV_args': 'root=/dev/xvda1',
+            'PV_bootloader_args': '',
+            'PV_legacy_args': '',
+            'HVM_boot_policy': '',
+            'HVM_boot_params': {},
+            'platform': {},
+            'PCI_bus': '',
+            'recommendations': '',
+            'affinity': '',
+            'user_version': '0',
+            'other_config': {},
+            }
+        logging.debug('Created VM %s...', Instance.get_name(instance))
+        vm_ref = yield session.call_xenapi('VM.create', rec)
+        logging.debug('Created VM %s as %s.',
+                      Instance.get_name(instance), vm_ref)
+        defer.returnValue(vm_ref)
+
+    @classmethod
+    @defer.inlineCallbacks
+    def create_vbd(self, 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
+        vbd_rec['userdevice'] = str(userdevice)
+        vbd_rec['bootable'] = bootable
+        vbd_rec['mode'] = 'RW'
+        vbd_rec['type'] = 'disk'
+        vbd_rec['unpluggable'] = True
+        vbd_rec['empty'] = False
+        vbd_rec['other_config'] = {}
+        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)
+        vbd_ref = yield session.call_xenapi('VBD.create', vbd_rec)
+        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
+                      vdi_ref)
+        defer.returnValue(vbd_ref)
+
+    @classmethod
+    @defer.inlineCallbacks
+    def create_vif(self, 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
+        vif_rec['VM'] = vm_ref
+        vif_rec['MAC'] = mac_address
+        vif_rec['MTU'] = '1500'
+        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,
+                      network_ref)
+        vif_ref = yield session.call_xenapi('VIF.create', vif_rec)
+        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
+                      vm_ref, network_ref)
+        defer.returnValue(vif_ref)
+
+    @classmethod
+    @defer.inlineCallbacks
+    def fetch_image(self, session, image, user, project, use_sr):
+        """use_sr: True to put the image as a VDI in an SR, False to place
+        it on dom0's filesystem.  The former is for VM disks, the latter for
+        its kernel and ramdisk (if external kernels are being used).
+        Returns a Deferred that gives the new VDI UUID."""
+
+        url = Image.get_url(image)
+        access = User.get_access(user, project)
+        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
+        args['username'] = access
+        args['password'] = User.get_secret(user)
+        if use_sr:
+            args['add_partition'] = 'true'
+        task = yield session.async_call_plugin('objectstore', fn, args)
+        uuid = yield session.wait_for_task(task)
+        defer.returnValue(uuid)
+
+    @classmethod
+    @utils.deferredToThread
+    def lookup(self, session, i):
+        return VMHelper.lookup_blocking(session, i)
+
+    @classmethod
+    def lookup_blocking(self, session, i):
+        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)
+        else:
+            return vms[0]
+
+    @classmethod
+    @utils.deferredToThread
+    def lookup_vm_vdis(self, session, vm):
+        return VMHelper.lookup_vm_vdis_blocking(session, vm)
+
+    @classmethod
+    def lookup_vm_vdis_blocking(self, session, vm):
+        # Firstly we get the VBDs, then the VDIs.
+        # TODO: do we leave the read-only devices?
+        vbds = session.get_xenapi().VM.get_VBDs(vm)
+        vdis = []
+        if vbds:
+            for vbd in vbds:
+                try:
+                    vdi = session.get_xenapi().VBD.get_VDI(vbd)
+                    # Test valid VDI
+                    record = session.get_xenapi().VDI.get_record(vdi)
+                except Exception, exc:
+                    logging.warn(exc)
+                else:
+                    vdis.append(vdi)
+            if len(vdis) > 0:
+                return vdis
+            else:
+                return None
diff --git a/nova/virt/xapi/vmops.py b/nova/virt/xapi/vmops.py
new file mode 100644
index 000000000..d6ea5e7db
--- /dev/null
+++ b/nova/virt/xapi/vmops.py
@@ -0,0 +1,123 @@
+# 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.
+
+"""
+Management class for VM-related functions (spawn, reboot, etc).
+"""
+
+import logging
+
+from twisted.internet import defer
+
+from novadeps import XENAPI_POWER_STATE
+from novadeps import Instance
+from novadeps import Network
+
+from vm_utils import VMHelper
+from network_utils import NetworkHelper
+
+
+class VMOps(object):
+    def __init__(self, session):
+        self._session = session
+
+    def list_instances(self):
+        return [self._session.get_xenapi().VM.get_name_label(vm) \
+                for vm in self._session.get_xenapi().VM.get_all()]
+
+    @defer.inlineCallbacks
+    def spawn(self, instance):
+        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
+        if vm is not None:
+            raise Exception('Attempted to create non-unique name %s' %
+                            Instance.get_name(instance))
+
+        bridge = Network.get_bridge(Instance.get_network(instance))
+        network_ref = \
+            yield NetworkHelper.find_network_with_bridge(self._session, bridge)
+
+        user = Instance.get_user(instance)
+        project = Instance.get_project(instance)
+        vdi_uuid = yield VMHelper.fetch_image(self._session,
+            Instance.get_image_id(instance), user, project, True)
+        kernel = yield VMHelper.fetch_image(self._session,
+            Instance.get_kernel_id(instance), user, project, False)
+        ramdisk = yield VMHelper.fetch_image(self._session,
+            Instance.get_ramdisk_id(instance), user, project, False)
+        vdi_ref = yield self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
+        vm_ref = yield VMHelper.create_vm(self._session,
+                                          instance, kernel, ramdisk)
+        yield VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
+        if network_ref:
+            yield VMHelper.create_vif(self._session, vm_ref,
+                                      network_ref, Instance.get_mac(instance))
+        logging.debug('Starting VM %s...', vm_ref)
+        yield self._session.call_xenapi('VM.start', vm_ref, False, False)
+        logging.info('Spawning VM %s created %s.', Instance.get_name(instance),
+                     vm_ref)
+
+    @defer.inlineCallbacks
+    def reboot(self, instance):
+        instance_name = Instance.get_name(instance)
+        vm = yield VMHelper.lookup(self._session, instance_name)
+        if vm is None:
+            raise Exception('instance not present %s' % instance_name)
+        task = yield self._session.call_xenapi('Async.VM.clean_reboot', vm)
+        yield self._session.wait_for_task(task)
+
+    @defer.inlineCallbacks
+    def destroy(self, instance):
+        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
+        if vm is None:
+            # Don't complain, just return.  This lets us clean up instances
+            # that have already disappeared from the underlying platform.
+            defer.returnValue(None)
+        # Get the VDIs related to the VM
+        vdis = yield VMHelper.lookup_vm_vdis(self._session, vm)
+        try:
+            task = yield self._session.call_xenapi('Async.VM.hard_shutdown',
+                                                   vm)
+            yield self._session.wait_for_task(task)
+        except Exception, exc:
+            logging.warn(exc)
+        # Disk clean-up
+        if vdis:
+            for vdi in vdis:
+                try:
+                    task = yield self._session.call_xenapi('Async.VDI.destroy',
+                                                           vdi)
+                    yield self._session.wait_for_task(task)
+                except Exception, exc:
+                    logging.warn(exc)
+        try:
+            task = yield self._session.call_xenapi('Async.VM.destroy', vm)
+            yield self._session.wait_for_task(task)
+        except Exception, exc:
+            logging.warn(exc)
+
+    def get_info(self, instance_id):
+        vm = VMHelper.lookup_blocking(self._session, instance_id)
+        if vm is None:
+            raise Exception('instance not present %s' % instance_id)
+        rec = self._session.get_xenapi().VM.get_record(vm)
+        return {'state': XENAPI_POWER_STATE[rec['power_state']],
+                'max_mem': long(rec['memory_static_max']) >> 10,
+                'mem': long(rec['memory_dynamic_max']) >> 10,
+                'num_cpu': rec['VCPUs_max'],
+                'cpu_time': 0}
+
+    def get_console_output(self, instance):
+        return 'FAKE CONSOLE OUTPUT'
diff --git a/nova/virt/xapi/volumeops.py b/nova/virt/xapi/volumeops.py
new file mode 100644
index 000000000..23f79adf7
--- /dev/null
+++ b/nova/virt/xapi/volumeops.py
@@ -0,0 +1,30 @@
+# 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.
+
+"""
+Management class for Storage-related functions (attach, detach, etc).
+"""
+
+
+class VolumeOps(object):
+    def __init__(self, session):
+        self._session = session
+
+    def attach_volume(self, instance_name, device_path, mountpoint):
+        return True
+
+    def detach_volume(self, instance_name, mountpoint):
+        return True
diff --git a/nova/virt/xenapi.py b/nova/virt/xenapi.py
index 2f2cef75e..613f19f82 100644
--- a/nova/virt/xenapi.py
+++ b/nova/virt/xenapi.py
@@ -52,10 +52,13 @@ import xmlrpclib
 
 from twisted.internet import defer
 from twisted.internet import reactor
-from twisted.internet import task
+#from twisted.internet import task
 
-from xenapi import VMOps
-from xenapi import VolumeOps
+from nova import flags
+from nova import utils
+
+from xapi.vmops import VMOps
+from xapi.volumeops import VolumeOps
 
 XenAPI = None
 
@@ -151,7 +154,7 @@ class XenAPISession(object):
         for m in method.split('.'):
             f = f.__getattr__(m)
         return f(*args)
-        
+
     @utils.deferredToThread
     def async_call_plugin(self, plugin, fn, args):
         """Call Async.host.call_plugin on a background thread.  Returns a
diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py
deleted file mode 100644
index 83ade1389..000000000
--- a/nova/virt/xenapi/network_utils.py
+++ /dev/null
@@ -1,42 +0,0 @@
-# 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 network records and 
-their attributes like bridges, PIFs, QoS, as well as their lookup functions.
-"""
-
-import logging
-import xmlrpclib
-
-from twisted.internet import defer
-from twisted.internet import reactor
-from twisted.internet import task
-          
-                
-class NetworkHelper():
-    @classmethod
-    @defer.inlineCallbacks
-    def find_network_with_bridge(self, session, bridge):
-        expr = 'field "bridge" = "%s"' % bridge
-        networks = yield session.call_xenapi('network.get_all_records_where',
-                                           expr)
-        if len(networks) == 1:
-            defer.returnValue(networks.keys()[0])
-        elif len(networks) > 1:
-            raise Exception('Found non-unique network for bridge %s' % bridge)
-        else:
-            raise Exception('Found no network for bridge %s' % bridge)
\ No newline at end of file
diff --git a/nova/virt/xenapi/novadeps.py b/nova/virt/xenapi/novadeps.py
deleted file mode 100644
index a4e512263..000000000
--- a/nova/virt/xenapi/novadeps.py
+++ /dev/null
@@ -1,97 +0,0 @@
-# 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.
-
-from nova import db
-from nova import flags
-from nova import process
-from nova import utils
-
-from nova.compute import power_state
-from nova.auth.manager import AuthManager
-from nova.compute import instance_types
-from nova.virt import images   
-
-XENAPI_POWER_STATE = {
-    'Halted': power_state.SHUTDOWN,
-    'Running': power_state.RUNNING,
-    'Paused': power_state.PAUSED,
-    'Suspended': power_state.SHUTDOWN,  # FIXME
-    'Crashed': power_state.CRASHED}
-    
-class Instance(object):
-
-    @classmethod
-    def get_name(self, instance):
-        return instance.name
-        
-    @classmethod
-    def get_type(self, instance):
-        return instance_types.INSTANCE_TYPES[instance.instance_type]
- 
-    @classmethod
-    def get_project(self, instance):
-        return AuthManager().get_project(instance.project_id)
-            
-    @classmethod
-    def get_project_id(self, instance):
-        return instance.project_id
-                            
-    @classmethod
-    def get_image_id(self, instance):
-        return instance.image_id
-        
-    @classmethod
-    def get_kernel_id(self, instance):
-        return instance.kernel_id
-                    
-    @classmethod
-    def get_ramdisk_id(self, instance):
-        return instance.ramdisk_id
-
-    @classmethod
-    def get_network(self, instance):
-        return db.project_get_network(None, instance.project_id)
-    
-    @classmethod
-    def get_mac(self, instance):
-        return instance.mac_address
-    
-    @classmethod
-    def get_user(self, instance):
-        return AuthManager().get_user(instance.user_id)
-        
-
-class Network(object):
-
-    @classmethod
-    def get_bridge(self, network):
-        return network.bridge
-        
-class Image(object):
-
-    @classmethod
-    def get_url(self, image):
-        return images.image_url(image)
-        
-class User(object):
-
-    @classmethod
-    def get_access(self, user, project):
-        return AuthManager().get_access_key(user, project)
-
-    @classmethod
-    def get_secret(self, user):
-        return user.secret
\ No newline at end of file
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
deleted file mode 100644
index a1b444e41..000000000
--- a/nova/virt/xenapi/vm_utils.py
+++ /dev/null
@@ -1,192 +0,0 @@
-# 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 VM records and 
-their attributes like VDIs, VIFs, as well as their lookup functions.
-"""
-
-import logging
-import xmlrpclib
-
-from twisted.internet import defer
-from twisted.internet import reactor
-from twisted.internet import task
-
-from nova import db
-from nova import flags
-from nova import process
-from nova import utils
-
-from novadeps import Instance
-from novadeps import Image
-from novadeps import User
-          
-                
-class VMHelper():
-    @classmethod
-    @defer.inlineCallbacks
-    def create_vm(self, session, instance, kernel, ramdisk):
-        """Create a VM record.  Returns a Deferred that gives the new
-        VM reference."""
-
-        instance_type = Instance.get_type(instance) 
-        mem = str(long(instance_type['memory_mb']) * 1024 * 1024)
-        vcpus = str(instance_type['vcpus'])
-        rec = {
-            'name_label': instance.name,
-            'name_description': '',
-            'is_a_template': False,
-            'memory_static_min': '0',
-            'memory_static_max': mem,
-            'memory_dynamic_min': mem,
-            'memory_dynamic_max': mem,
-            'VCPUs_at_startup': vcpus,
-            'VCPUs_max': vcpus,
-            'VCPUs_params': {},
-            'actions_after_shutdown': 'destroy',
-            'actions_after_reboot': 'restart',
-            'actions_after_crash': 'destroy',
-            'PV_bootloader': '',
-            'PV_kernel': kernel,
-            'PV_ramdisk': ramdisk,
-            'PV_args': 'root=/dev/xvda1',
-            'PV_bootloader_args': '',
-            'PV_legacy_args': '',
-            'HVM_boot_policy': '',
-            'HVM_boot_params': {},
-            'platform': {},
-            'PCI_bus': '',
-            'recommendations': '',
-            'affinity': '',
-            'user_version': '0',
-            'other_config': {},
-            }
-        logging.debug('Created VM %s...', Instance.get_name(instance))
-        vm_ref = yield session.call_xenapi('VM.create', rec)
-        logging.debug('Created VM %s as %s.', Instance.get_name(instance), vm_ref)
-        defer.returnValue(vm_ref)
-        
-    @classmethod    
-    @defer.inlineCallbacks
-    def create_vbd(self, 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
-        vbd_rec['userdevice'] = str(userdevice)
-        vbd_rec['bootable'] = bootable
-        vbd_rec['mode'] = 'RW'
-        vbd_rec['type'] = 'disk'
-        vbd_rec['unpluggable'] = True
-        vbd_rec['empty'] = False
-        vbd_rec['other_config'] = {}
-        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)
-        vbd_ref = yield session.call_xenapi('VBD.create', vbd_rec)
-        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
-                      vdi_ref)
-        defer.returnValue(vbd_ref)
-
-    @classmethod    
-    @defer.inlineCallbacks
-    def create_vif(self, 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
-        vif_rec['VM'] = vm_ref
-        vif_rec['MAC'] = mac_address
-        vif_rec['MTU'] = '1500'
-        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,
-                      network_ref)
-        vif_ref = yield session.call_xenapi('VIF.create', vif_rec)
-        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
-                      vm_ref, network_ref)
-        defer.returnValue(vif_ref)
-
-    @classmethod
-    @defer.inlineCallbacks
-    def fetch_image(self, session, image, user, project, use_sr):
-        """use_sr: True to put the image as a VDI in an SR, False to place
-        it on dom0's filesystem.  The former is for VM disks, the latter for
-        its kernel and ramdisk (if external kernels are being used).
-        Returns a Deferred that gives the new VDI UUID."""
-
-        url = Image.get_url(image)
-        access = User.get_access(user, project)
-        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
-        args['username'] = access
-        args['password'] = User.get_secret(user)
-        if use_sr:
-            args['add_partition'] = 'true'
-        task = yield session.async_call_plugin('objectstore', fn, args)
-        uuid = yield session.wait_for_task(task)
-        defer.returnValue(uuid)    
-    
-    @classmethod    
-    @utils.deferredToThread
-    def lookup(self, session, i):
-        return VMHelper.lookup_blocking(session, i)
-
-    @classmethod
-    def lookup_blocking(self, session, i):
-        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)
-        else:
-            return vms[0]
-
-    @classmethod    
-    @utils.deferredToThread
-    def lookup_vm_vdis(self, session, vm):
-        return VMHelper.lookup_vm_vdis_blocking(session, vm)
-
-    @classmethod
-    def lookup_vm_vdis_blocking(self, session, vm):
-        # Firstly we get the VBDs, then the VDIs.
-        # TODO: do we leave the read-only devices?
-        vbds = session.get_xenapi().VM.get_VBDs(vm)
-        vdis = []
-        if vbds:
-            for vbd in vbds:
-                try:
-                    vdi = session.get_xenapi().VBD.get_VDI(vbd)
-                    # Test valid VDI
-                    record = session.get_xenapi().VDI.get_record(vdi)
-                except Exception, exc:
-                    logging.warn(exc)
-                else:
-                    vdis.append(vdi)
-            if len(vdis) > 0:
-                return vdis
-            else:
-                return None
\ No newline at end of file
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
deleted file mode 100644
index c04a9f4ec..000000000
--- a/nova/virt/xenapi/vmops.py
+++ /dev/null
@@ -1,122 +0,0 @@
-# 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.
-
-"""
-Management class for VM-related functions (spawn, reboot, etc).
-"""
-
-import logging
-import xmlrpclib
-
-from twisted.internet import defer
-from twisted.internet import reactor
-from twisted.internet import task
-
-import VMHelper
-import NetworkHelper
-
-from novadeps import XENAPI_POWER_STATE
-from novadeps import Auth
-from novadeps import Instance
-from novadeps import Network
-
-class VMOps(object):
-    def __init__(self, session):
-        self._session = session
-    
-    def list_instances(self):
-        return [self._session.get_xenapi().VM.get_name_label(vm) \
-                for vm in self._session.get_xenapi().VM.get_all()]
-
-    @defer.inlineCallbacks
-    def spawn(self, instance):
-        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
-        if vm is not None:
-            raise Exception('Attempted to create non-unique name %s' %
-                            Instance.get_name(instance))
-
-        network = Instance.get_network(instance)
-        network_ref = \
-            yield NetworkHelper.find_network_with_bridge(self._session, Network.get_bridge(network))
-
-        user = Instance.get_user(instance)
-        project = Instance.get_project(instance)
-        vdi_uuid = yield VMHelper.fetch_image(self._session,
-            Instance.get_image_id(instance), user, project, True)
-        kernel = yield VMHelper.fetch_image(self._session,
-            Instance.get_kernel_id(instance), user, project, False)
-        ramdisk = yield VMHelper.fetch_image(self._session,
-            Instance.get_ramdisk_id(instance), user, project, False)
-        vdi_ref = yield self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
-
-        vm_ref = yield VMHelper.create_vm(self._session, instance, kernel, ramdisk)
-        yield VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
-        if network_ref:
-            yield VMHelper.create_vif(self._session, vm_ref, network_ref, Instance.get_mac(instance))
-        logging.debug('Starting VM %s...', vm_ref)
-        yield self._session.call_xenapi('VM.start', vm_ref, False, False)
-        logging.info('Spawning VM %s created %s.', Instance.get_name(instance), vm_ref)
-
-    @defer.inlineCallbacks
-    def reboot(self, instance):
-        instance_name = Instance.get_name(instance)
-        vm = yield VMHelper.lookup(self._session, instance_name)
-        if vm is None:
-            raise Exception('instance not present %s' % instance_name)
-        task = yield self._session.call_xenapi('Async.VM.clean_reboot', vm)
-        yield self._session.wait_for_task(task)
-
-    @defer.inlineCallbacks
-    def destroy(self, instance):
-        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
-        if vm is None:
-            # Don't complain, just return.  This lets us clean up instances
-            # that have already disappeared from the underlying platform.
-            defer.returnValue(None)
-        # Get the VDIs related to the VM
-        vdis = yield VMHelper.lookup_vm_vdis(self._session, vm)
-        try:
-            task = yield self._session.call_xenapi('Async.VM.hard_shutdown', vm)
-            yield self._session.wait_for_task(task)
-        except Exception, exc:
-            logging.warn(exc)
-        # Disk clean-up
-        if vdis:
-            for vdi in vdis:
-                try:
-                    task = yield self._session.call_xenapi('Async.VDI.destroy', vdi)
-                    yield self._session.wait_for_task(task)
-                except Exception, exc:
-                    logging.warn(exc)
-        try:
-            task = yield self._session.call_xenapi('Async.VM.destroy', vm)
-            yield self._session.wait_for_task(task)
-        except Exception, exc:
-            logging.warn(exc)
-
-    def get_info(self, instance_id):
-        vm = VMHelper.lookup_blocking(self._session, instance_id)
-        if vm is None:
-            raise Exception('instance not present %s' % instance_id)
-        rec = self._session.get_xenapi().VM.get_record(vm)
-        return {'state': XENAPI_POWER_STATE[rec['power_state']],
-                'max_mem': long(rec['memory_static_max']) >> 10,
-                'mem': long(rec['memory_dynamic_max']) >> 10,
-                'num_cpu': rec['VCPUs_max'],
-                'cpu_time': 0}
-
-    def get_console_output(self, instance):
-        return 'FAKE CONSOLE OUTPUT'
\ No newline at end of file
diff --git a/nova/virt/xenapi/volumeops.py b/nova/virt/xenapi/volumeops.py
deleted file mode 100644
index fd316a0b8..000000000
--- a/nova/virt/xenapi/volumeops.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# 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.
-
-"""
-Management class for Storage-related functions (attach, detach, etc).
-"""
-
-
-class VMOps(object):
-    def __init__(self, session):
-        self._session = session
-
-    def attach_volume(self, instance_name, device_path, mountpoint):
-        return True
-
-    def detach_volume(self, instance_name, mountpoint):
-        return True
\ No newline at end of file
-- 
cgit 


From a82581cbada92d0e274438757f7beb3ed335da1b Mon Sep 17 00:00:00 2001
From: Armando Migliaccio <armando.migliaccio@citrix.com>
Date: Mon, 29 Nov 2010 16:31:31 +0000
Subject: pep8 fixes and further round of refactoring

---
 nova/virt/connection.py           |   4 +-
 nova/virt/xapi/__init__.py        |  15 ---
 nova/virt/xapi/network_utils.py   |  40 -------
 nova/virt/xapi/novadeps.py        | 100 -----------------
 nova/virt/xapi/vm_utils.py        | 190 -------------------------------
 nova/virt/xapi/vmops.py           | 123 --------------------
 nova/virt/xapi/volumeops.py       |  30 -----
 nova/virt/xenapi.py               | 228 --------------------------------------
 nova/virt/xenapi/__init__.py      |  15 +++
 nova/virt/xenapi/network_utils.py |  40 +++++++
 nova/virt/xenapi/novadeps.py      | 103 +++++++++++++++++
 nova/virt/xenapi/vm_utils.py      | 190 +++++++++++++++++++++++++++++++
 nova/virt/xenapi/vmops.py         | 123 ++++++++++++++++++++
 nova/virt/xenapi/volumeops.py     |  30 +++++
 nova/virt/xenapi_conn.py          | 227 +++++++++++++++++++++++++++++++++++++
 15 files changed, 730 insertions(+), 728 deletions(-)
 delete mode 100644 nova/virt/xapi/__init__.py
 delete mode 100644 nova/virt/xapi/network_utils.py
 delete mode 100644 nova/virt/xapi/novadeps.py
 delete mode 100644 nova/virt/xapi/vm_utils.py
 delete mode 100644 nova/virt/xapi/vmops.py
 delete mode 100644 nova/virt/xapi/volumeops.py
 delete mode 100644 nova/virt/xenapi.py
 create mode 100644 nova/virt/xenapi/__init__.py
 create mode 100644 nova/virt/xenapi/network_utils.py
 create mode 100644 nova/virt/xenapi/novadeps.py
 create mode 100644 nova/virt/xenapi/vm_utils.py
 create mode 100644 nova/virt/xenapi/vmops.py
 create mode 100644 nova/virt/xenapi/volumeops.py
 create mode 100644 nova/virt/xenapi_conn.py

diff --git a/nova/virt/connection.py b/nova/virt/connection.py
index 11f0fa8ce..c40bb4bb4 100644
--- a/nova/virt/connection.py
+++ b/nova/virt/connection.py
@@ -25,7 +25,7 @@ import sys
 from nova import flags
 from nova.virt import fake
 from nova.virt import libvirt_conn
-from nova.virt import xenapi
+from nova.virt import xenapi_conn
 
 
 FLAGS = flags.FLAGS
@@ -61,7 +61,7 @@ def get_connection(read_only=False):
     elif t == 'libvirt':
         conn = libvirt_conn.get_connection(read_only)
     elif t == 'xenapi':
-        conn = xenapi.get_connection(read_only)
+        conn = xenapi_conn.get_connection(read_only)
     else:
         raise Exception('Unknown connection type "%s"' % t)
 
diff --git a/nova/virt/xapi/__init__.py b/nova/virt/xapi/__init__.py
deleted file mode 100644
index 3d598c463..000000000
--- a/nova/virt/xapi/__init__.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# 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.
diff --git a/nova/virt/xapi/network_utils.py b/nova/virt/xapi/network_utils.py
deleted file mode 100644
index b58b9159c..000000000
--- a/nova/virt/xapi/network_utils.py
+++ /dev/null
@@ -1,40 +0,0 @@
-# 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 network records and
-their attributes like bridges, PIFs, QoS, as well as their lookup functions.
-"""
-
-from twisted.internet import defer
-
-
-class NetworkHelper():
-    def __init__(self, session):
-        return
-
-    @classmethod
-    @defer.inlineCallbacks
-    def find_network_with_bridge(self, session, bridge):
-        expr = 'field "bridge" = "%s"' % bridge
-        networks = yield session.call_xenapi('network.get_all_records_where',
-                                           expr)
-        if len(networks) == 1:
-            defer.returnValue(networks.keys()[0])
-        elif len(networks) > 1:
-            raise Exception('Found non-unique network for bridge %s' % bridge)
-        else:
-            raise Exception('Found no network for bridge %s' % bridge)
diff --git a/nova/virt/xapi/novadeps.py b/nova/virt/xapi/novadeps.py
deleted file mode 100644
index 8cb5e3246..000000000
--- a/nova/virt/xapi/novadeps.py
+++ /dev/null
@@ -1,100 +0,0 @@
-# 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.
-
-from nova import db
-from nova import flags
-from nova import process
-from nova import utils
-
-from nova.compute import power_state
-from nova.auth.manager import AuthManager
-from nova.compute import instance_types
-from nova.virt import images
-
-XENAPI_POWER_STATE = {
-    'Halted': power_state.SHUTDOWN,
-    'Running': power_state.RUNNING,
-    'Paused': power_state.PAUSED,
-    'Suspended': power_state.SHUTDOWN,  # FIXME
-    'Crashed': power_state.CRASHED}
-
-
-class Instance(object):
-
-    @classmethod
-    def get_name(self, instance):
-        return instance.name
-
-    @classmethod
-    def get_type(self, instance):
-        return instance_types.INSTANCE_TYPES[instance.instance_type]
-
-    @classmethod
-    def get_project(self, instance):
-        return AuthManager().get_project(instance.project_id)
-
-    @classmethod
-    def get_project_id(self, instance):
-        return instance.project_id
-
-    @classmethod
-    def get_image_id(self, instance):
-        return instance.image_id
-
-    @classmethod
-    def get_kernel_id(self, instance):
-        return instance.kernel_id
-
-    @classmethod
-    def get_ramdisk_id(self, instance):
-        return instance.ramdisk_id
-
-    @classmethod
-    def get_network(self, instance):
-        return db.project_get_network(None, instance.project_id)
-
-    @classmethod
-    def get_mac(self, instance):
-        return instance.mac_address
-
-    @classmethod
-    def get_user(self, instance):
-        return AuthManager().get_user(instance.user_id)
-
-
-class Network(object):
-
-    @classmethod
-    def get_bridge(self, network):
-        return network.bridge
-
-
-class Image(object):
-
-    @classmethod
-    def get_url(self, image):
-        return images.image_url(image)
-
-
-class User(object):
-
-    @classmethod
-    def get_access(self, user, project):
-        return AuthManager().get_access_key(user, project)
-
-    @classmethod
-    def get_secret(self, user):
-        return user.secret
diff --git a/nova/virt/xapi/vm_utils.py b/nova/virt/xapi/vm_utils.py
deleted file mode 100644
index 41f687ccb..000000000
--- a/nova/virt/xapi/vm_utils.py
+++ /dev/null
@@ -1,190 +0,0 @@
-# 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 VM records and
-their attributes like VDIs, VIFs, as well as their lookup functions.
-"""
-
-import logging
-
-from twisted.internet import defer
-
-from nova import utils
-
-from novadeps import Instance
-from novadeps import Image
-from novadeps import User
-
-
-class VMHelper():
-    def __init__(self, session):
-        return
-    
-    @classmethod
-    @defer.inlineCallbacks
-    def create_vm(self, session, instance, kernel, ramdisk):
-        """Create a VM record.  Returns a Deferred that gives the new
-        VM reference."""
-
-        instance_type = Instance.get_type(instance)
-        mem = str(long(instance_type['memory_mb']) * 1024 * 1024)
-        vcpus = str(instance_type['vcpus'])
-        rec = {
-            'name_label': instance.name,
-            'name_description': '',
-            'is_a_template': False,
-            'memory_static_min': '0',
-            'memory_static_max': mem,
-            'memory_dynamic_min': mem,
-            'memory_dynamic_max': mem,
-            'VCPUs_at_startup': vcpus,
-            'VCPUs_max': vcpus,
-            'VCPUs_params': {},
-            'actions_after_shutdown': 'destroy',
-            'actions_after_reboot': 'restart',
-            'actions_after_crash': 'destroy',
-            'PV_bootloader': '',
-            'PV_kernel': kernel,
-            'PV_ramdisk': ramdisk,
-            'PV_args': 'root=/dev/xvda1',
-            'PV_bootloader_args': '',
-            'PV_legacy_args': '',
-            'HVM_boot_policy': '',
-            'HVM_boot_params': {},
-            'platform': {},
-            'PCI_bus': '',
-            'recommendations': '',
-            'affinity': '',
-            'user_version': '0',
-            'other_config': {},
-            }
-        logging.debug('Created VM %s...', Instance.get_name(instance))
-        vm_ref = yield session.call_xenapi('VM.create', rec)
-        logging.debug('Created VM %s as %s.',
-                      Instance.get_name(instance), vm_ref)
-        defer.returnValue(vm_ref)
-
-    @classmethod
-    @defer.inlineCallbacks
-    def create_vbd(self, 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
-        vbd_rec['userdevice'] = str(userdevice)
-        vbd_rec['bootable'] = bootable
-        vbd_rec['mode'] = 'RW'
-        vbd_rec['type'] = 'disk'
-        vbd_rec['unpluggable'] = True
-        vbd_rec['empty'] = False
-        vbd_rec['other_config'] = {}
-        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)
-        vbd_ref = yield session.call_xenapi('VBD.create', vbd_rec)
-        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
-                      vdi_ref)
-        defer.returnValue(vbd_ref)
-
-    @classmethod
-    @defer.inlineCallbacks
-    def create_vif(self, 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
-        vif_rec['VM'] = vm_ref
-        vif_rec['MAC'] = mac_address
-        vif_rec['MTU'] = '1500'
-        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,
-                      network_ref)
-        vif_ref = yield session.call_xenapi('VIF.create', vif_rec)
-        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
-                      vm_ref, network_ref)
-        defer.returnValue(vif_ref)
-
-    @classmethod
-    @defer.inlineCallbacks
-    def fetch_image(self, session, image, user, project, use_sr):
-        """use_sr: True to put the image as a VDI in an SR, False to place
-        it on dom0's filesystem.  The former is for VM disks, the latter for
-        its kernel and ramdisk (if external kernels are being used).
-        Returns a Deferred that gives the new VDI UUID."""
-
-        url = Image.get_url(image)
-        access = User.get_access(user, project)
-        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
-        args['username'] = access
-        args['password'] = User.get_secret(user)
-        if use_sr:
-            args['add_partition'] = 'true'
-        task = yield session.async_call_plugin('objectstore', fn, args)
-        uuid = yield session.wait_for_task(task)
-        defer.returnValue(uuid)
-
-    @classmethod
-    @utils.deferredToThread
-    def lookup(self, session, i):
-        return VMHelper.lookup_blocking(session, i)
-
-    @classmethod
-    def lookup_blocking(self, session, i):
-        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)
-        else:
-            return vms[0]
-
-    @classmethod
-    @utils.deferredToThread
-    def lookup_vm_vdis(self, session, vm):
-        return VMHelper.lookup_vm_vdis_blocking(session, vm)
-
-    @classmethod
-    def lookup_vm_vdis_blocking(self, session, vm):
-        # Firstly we get the VBDs, then the VDIs.
-        # TODO: do we leave the read-only devices?
-        vbds = session.get_xenapi().VM.get_VBDs(vm)
-        vdis = []
-        if vbds:
-            for vbd in vbds:
-                try:
-                    vdi = session.get_xenapi().VBD.get_VDI(vbd)
-                    # Test valid VDI
-                    record = session.get_xenapi().VDI.get_record(vdi)
-                except Exception, exc:
-                    logging.warn(exc)
-                else:
-                    vdis.append(vdi)
-            if len(vdis) > 0:
-                return vdis
-            else:
-                return None
diff --git a/nova/virt/xapi/vmops.py b/nova/virt/xapi/vmops.py
deleted file mode 100644
index d6ea5e7db..000000000
--- a/nova/virt/xapi/vmops.py
+++ /dev/null
@@ -1,123 +0,0 @@
-# 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.
-
-"""
-Management class for VM-related functions (spawn, reboot, etc).
-"""
-
-import logging
-
-from twisted.internet import defer
-
-from novadeps import XENAPI_POWER_STATE
-from novadeps import Instance
-from novadeps import Network
-
-from vm_utils import VMHelper
-from network_utils import NetworkHelper
-
-
-class VMOps(object):
-    def __init__(self, session):
-        self._session = session
-
-    def list_instances(self):
-        return [self._session.get_xenapi().VM.get_name_label(vm) \
-                for vm in self._session.get_xenapi().VM.get_all()]
-
-    @defer.inlineCallbacks
-    def spawn(self, instance):
-        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
-        if vm is not None:
-            raise Exception('Attempted to create non-unique name %s' %
-                            Instance.get_name(instance))
-
-        bridge = Network.get_bridge(Instance.get_network(instance))
-        network_ref = \
-            yield NetworkHelper.find_network_with_bridge(self._session, bridge)
-
-        user = Instance.get_user(instance)
-        project = Instance.get_project(instance)
-        vdi_uuid = yield VMHelper.fetch_image(self._session,
-            Instance.get_image_id(instance), user, project, True)
-        kernel = yield VMHelper.fetch_image(self._session,
-            Instance.get_kernel_id(instance), user, project, False)
-        ramdisk = yield VMHelper.fetch_image(self._session,
-            Instance.get_ramdisk_id(instance), user, project, False)
-        vdi_ref = yield self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
-        vm_ref = yield VMHelper.create_vm(self._session,
-                                          instance, kernel, ramdisk)
-        yield VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
-        if network_ref:
-            yield VMHelper.create_vif(self._session, vm_ref,
-                                      network_ref, Instance.get_mac(instance))
-        logging.debug('Starting VM %s...', vm_ref)
-        yield self._session.call_xenapi('VM.start', vm_ref, False, False)
-        logging.info('Spawning VM %s created %s.', Instance.get_name(instance),
-                     vm_ref)
-
-    @defer.inlineCallbacks
-    def reboot(self, instance):
-        instance_name = Instance.get_name(instance)
-        vm = yield VMHelper.lookup(self._session, instance_name)
-        if vm is None:
-            raise Exception('instance not present %s' % instance_name)
-        task = yield self._session.call_xenapi('Async.VM.clean_reboot', vm)
-        yield self._session.wait_for_task(task)
-
-    @defer.inlineCallbacks
-    def destroy(self, instance):
-        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
-        if vm is None:
-            # Don't complain, just return.  This lets us clean up instances
-            # that have already disappeared from the underlying platform.
-            defer.returnValue(None)
-        # Get the VDIs related to the VM
-        vdis = yield VMHelper.lookup_vm_vdis(self._session, vm)
-        try:
-            task = yield self._session.call_xenapi('Async.VM.hard_shutdown',
-                                                   vm)
-            yield self._session.wait_for_task(task)
-        except Exception, exc:
-            logging.warn(exc)
-        # Disk clean-up
-        if vdis:
-            for vdi in vdis:
-                try:
-                    task = yield self._session.call_xenapi('Async.VDI.destroy',
-                                                           vdi)
-                    yield self._session.wait_for_task(task)
-                except Exception, exc:
-                    logging.warn(exc)
-        try:
-            task = yield self._session.call_xenapi('Async.VM.destroy', vm)
-            yield self._session.wait_for_task(task)
-        except Exception, exc:
-            logging.warn(exc)
-
-    def get_info(self, instance_id):
-        vm = VMHelper.lookup_blocking(self._session, instance_id)
-        if vm is None:
-            raise Exception('instance not present %s' % instance_id)
-        rec = self._session.get_xenapi().VM.get_record(vm)
-        return {'state': XENAPI_POWER_STATE[rec['power_state']],
-                'max_mem': long(rec['memory_static_max']) >> 10,
-                'mem': long(rec['memory_dynamic_max']) >> 10,
-                'num_cpu': rec['VCPUs_max'],
-                'cpu_time': 0}
-
-    def get_console_output(self, instance):
-        return 'FAKE CONSOLE OUTPUT'
diff --git a/nova/virt/xapi/volumeops.py b/nova/virt/xapi/volumeops.py
deleted file mode 100644
index 23f79adf7..000000000
--- a/nova/virt/xapi/volumeops.py
+++ /dev/null
@@ -1,30 +0,0 @@
-# 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.
-
-"""
-Management class for Storage-related functions (attach, detach, etc).
-"""
-
-
-class VolumeOps(object):
-    def __init__(self, session):
-        self._session = session
-
-    def attach_volume(self, instance_name, device_path, mountpoint):
-        return True
-
-    def detach_volume(self, instance_name, mountpoint):
-        return True
diff --git a/nova/virt/xenapi.py b/nova/virt/xenapi.py
deleted file mode 100644
index 613f19f82..000000000
--- a/nova/virt/xenapi.py
+++ /dev/null
@@ -1,228 +0,0 @@
-# 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.
-
-"""
-A connection to XenServer or Xen Cloud Platform.
-
-The concurrency model for this class is as follows:
-
-All XenAPI calls are on a thread (using t.i.t.deferToThread, via the decorator
-deferredToThread).  They are remote calls, and so may hang for the usual
-reasons.  They should not be allowed to block the reactor thread.
-
-All long-running XenAPI calls (VM.start, VM.reboot, etc) are called async
-(using XenAPI.VM.async_start etc).  These return a task, which can then be
-polled for completion.  Polling is handled using reactor.callLater.
-
-This combination of techniques means that we don't block the reactor thread at
-all, and at the same time we don't hold lots of threads waiting for
-long-running operations.
-
-FIXME: get_info currently doesn't conform to these rules, and will block the
-reactor thread if the VM.get_by_name_label or VM.get_record calls block.
-
-**Related Flags**
-
-:xenapi_connection_url:  URL for connection to XenServer/Xen Cloud Platform.
-:xenapi_connection_username:  Username for connection to XenServer/Xen Cloud
-                              Platform (default: root).
-:xenapi_connection_password:  Password for connection to XenServer/Xen Cloud
-                              Platform.
-:xenapi_task_poll_interval:  The interval (seconds) used for polling of
-                             remote tasks (Async.VM.start, etc)
-                             (default: 0.5).
-
-"""
-
-import logging
-import xmlrpclib
-
-from twisted.internet import defer
-from twisted.internet import reactor
-#from twisted.internet import task
-
-from nova import flags
-from nova import utils
-
-from xapi.vmops import VMOps
-from xapi.volumeops import VolumeOps
-
-XenAPI = None
-
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('xenapi_connection_url',
-                    None,
-                    'URL for connection to XenServer/Xen Cloud Platform.'
-                    ' Required if connection_type=xenapi.')
-flags.DEFINE_string('xenapi_connection_username',
-                    'root',
-                    'Username for connection to XenServer/Xen Cloud Platform.'
-                    ' Used only if connection_type=xenapi.')
-flags.DEFINE_string('xenapi_connection_password',
-                    None,
-                    'Password for connection to XenServer/Xen Cloud Platform.'
-                    ' Used only if connection_type=xenapi.')
-flags.DEFINE_float('xenapi_task_poll_interval',
-                   0.5,
-                   'The interval used for polling of remote tasks '
-                   '(Async.VM.start, etc).  Used only if '
-                   'connection_type=xenapi.')
-
-
-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
-    if not url or password is None:
-        raise Exception('Must specify xenapi_connection_url, '
-                        'xenapi_connection_username (optionally), and '
-                        'xenapi_connection_password to use '
-                        'connection_type=xenapi')
-    return XenAPIConnection(url, username, password)
-
-
-class XenAPIConnection(object):
-    def __init__(self, url, user, pw):
-        session = XenAPISession(url, user, pw)
-        self._vmops = VMOps(session)
-        self._volumeops = VolumeOps(session)
-
-    def list_instances(self):
-        return self._vmops.list_instances()
-
-    def spawn(self, instance):
-        self._vmops.spawn(instance)
-
-    def reboot(self, instance):
-        self._vmops.reboot(instance)
-
-    def destroy(self, instance):
-        self._vmops.destroy(instance)
-
-    def get_info(self, instance_id):
-        return self._vmops.get_info(instance_id)
-
-    def get_console_output(self, instance):
-        return self._vmops.get_console_output(instance)
-
-    def attach_volume(self, instance_name, device_path, mountpoint):
-        return self._volumeops.attach_volume(instance_name,
-                                               device_path,
-                                               mountpoint)
-
-    def detach_volume(self, instance_name, mountpoint):
-        return self._volumeops.detach_volume(instance_name, mountpoint)
-
-
-class XenAPISession(object):
-    def __init__(self, url, user, pw):
-        self._session = XenAPI.Session(url)
-        self._session.login_with_password(user, pw)
-
-    def get_xenapi(self):
-        return self._session.xenapi
-
-    def get_xenapi_host(self):
-        return self._session.xenapi.session.get_this_host(self._session.handle)
-
-    @utils.deferredToThread
-    def call_xenapi(self, method, *args):
-        """Call the specified XenAPI method on a background thread.  Returns
-        a Deferred for the result."""
-        f = self._session.xenapi
-        for m in method.split('.'):
-            f = f.__getattr__(m)
-        return f(*args)
-
-    @utils.deferredToThread
-    def async_call_plugin(self, plugin, fn, args):
-        """Call Async.host.call_plugin on a background thread.  Returns a
-        Deferred with the task reference."""
-        return _unwrap_plugin_exceptions(
-            self._session.xenapi.Async.host.call_plugin,
-            self.get_xenapi_host(), plugin, fn, args)
-
-    def wait_for_task(self, task):
-        """Return a Deferred that will give the result of the given task.
-        The task is polled until it completes."""
-        d = defer.Deferred()
-        reactor.callLater(0, self._poll_task, task, d)
-        return d
-
-    @utils.deferredToThread
-    def _poll_task(self, task, deferred):
-        """Poll the given XenAPI task, and fire the given Deferred if we
-        get a result."""
-        try:
-            #logging.debug('Polling task %s...', task)
-            status = self._session.xenapi.task.get_status(task)
-            if status == 'pending':
-                reactor.callLater(FLAGS.xenapi_task_poll_interval,
-                                  self._poll_task, task, deferred)
-            elif status == 'success':
-                result = self._session.xenapi.task.get_result(task)
-                logging.info('Task %s status: success.  %s', task, result)
-                deferred.callback(_parse_xmlrpc_value(result))
-            else:
-                error_info = self._session.xenapi.task.get_error_info(task)
-                logging.warn('Task %s status: %s.  %s', task, status,
-                             error_info)
-                deferred.errback(XenAPI.Failure(error_info))
-            #logging.debug('Polling task %s done.', task)
-        except Exception, exc:
-            logging.warn(exc)
-            deferred.errback(exc)
-
-
-def _unwrap_plugin_exceptions(func, *args, **kwargs):
-    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:
-            raise
-    except xmlrpclib.ProtocolError, exc:
-        logging.debug("Got exception: %s", exc)
-        raise
-
-
-def _parse_xmlrpc_value(val):
-    """Parse the given value as if it were an XML-RPC value.  This is
-    sometimes used as the format for the task.result field."""
-    if not val:
-        return val
-    x = xmlrpclib.loads(
-        '<?xml version="1.0"?><methodResponse><params><param>' +
-        val +
-        '</param></params></methodResponse>')
-    return x[0][0]
diff --git a/nova/virt/xenapi/__init__.py b/nova/virt/xenapi/__init__.py
new file mode 100644
index 000000000..3d598c463
--- /dev/null
+++ b/nova/virt/xenapi/__init__.py
@@ -0,0 +1,15 @@
+# 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.
diff --git a/nova/virt/xenapi/network_utils.py b/nova/virt/xenapi/network_utils.py
new file mode 100644
index 000000000..b58b9159c
--- /dev/null
+++ b/nova/virt/xenapi/network_utils.py
@@ -0,0 +1,40 @@
+# 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 network records and
+their attributes like bridges, PIFs, QoS, as well as their lookup functions.
+"""
+
+from twisted.internet import defer
+
+
+class NetworkHelper():
+    def __init__(self, session):
+        return
+
+    @classmethod
+    @defer.inlineCallbacks
+    def find_network_with_bridge(self, session, bridge):
+        expr = 'field "bridge" = "%s"' % bridge
+        networks = yield session.call_xenapi('network.get_all_records_where',
+                                           expr)
+        if len(networks) == 1:
+            defer.returnValue(networks.keys()[0])
+        elif len(networks) > 1:
+            raise Exception('Found non-unique network for bridge %s' % bridge)
+        else:
+            raise Exception('Found no network for bridge %s' % bridge)
diff --git a/nova/virt/xenapi/novadeps.py b/nova/virt/xenapi/novadeps.py
new file mode 100644
index 000000000..ba62468fb
--- /dev/null
+++ b/nova/virt/xenapi/novadeps.py
@@ -0,0 +1,103 @@
+# 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.
+
+from nova import db
+from nova import flags
+from nova import process
+from nova import utils
+from nova import context
+
+from nova.compute import power_state
+from nova.auth.manager import AuthManager
+from nova.compute import instance_types
+from nova.virt import images
+
+XENAPI_POWER_STATE = {
+    'Halted': power_state.SHUTDOWN,
+    'Running': power_state.RUNNING,
+    'Paused': power_state.PAUSED,
+    'Suspended': power_state.SHUTDOWN,  # FIXME
+    'Crashed': power_state.CRASHED}
+
+
+class Instance(object):
+
+    @classmethod
+    def get_name(self, instance):
+        return instance.name
+
+    @classmethod
+    def get_type(self, instance):
+        return instance_types.INSTANCE_TYPES[instance.instance_type]
+
+    @classmethod
+    def get_project(self, instance):
+        return AuthManager().get_project(instance.project_id)
+
+    @classmethod
+    def get_project_id(self, instance):
+        return instance.project_id
+
+    @classmethod
+    def get_image_id(self, instance):
+        return instance.image_id
+
+    @classmethod
+    def get_kernel_id(self, instance):
+        return instance.kernel_id
+
+    @classmethod
+    def get_ramdisk_id(self, instance):
+        return instance.ramdisk_id
+
+    @classmethod
+    def get_network(self, instance):
+        # TODO: is ge_admin_context the right context to retrieve?
+        return db.project_get_network(context.get_admin_context(),
+                                      instance.project_id)
+
+    @classmethod
+    def get_mac(self, instance):
+        return instance.mac_address
+
+    @classmethod
+    def get_user(self, instance):
+        return AuthManager().get_user(instance.user_id)
+
+
+class Network(object):
+
+    @classmethod
+    def get_bridge(self, network):
+        return network.bridge
+
+
+class Image(object):
+
+    @classmethod
+    def get_url(self, image):
+        return images.image_url(image)
+
+
+class User(object):
+
+    @classmethod
+    def get_access(self, user, project):
+        return AuthManager().get_access_key(user, project)
+
+    @classmethod
+    def get_secret(self, user):
+        return user.secret
diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
new file mode 100644
index 000000000..b68df2791
--- /dev/null
+++ b/nova/virt/xenapi/vm_utils.py
@@ -0,0 +1,190 @@
+# 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 VM records and
+their attributes like VDIs, VIFs, as well as their lookup functions.
+"""
+
+import logging
+
+from twisted.internet import defer
+
+from nova import utils
+
+from novadeps import Instance
+from novadeps import Image
+from novadeps import User
+
+
+class VMHelper():
+    def __init__(self, session):
+        return
+
+    @classmethod
+    @defer.inlineCallbacks
+    def create_vm(self, session, instance, kernel, ramdisk):
+        """Create a VM record.  Returns a Deferred that gives the new
+        VM reference."""
+
+        instance_type = Instance.get_type(instance)
+        mem = str(long(instance_type['memory_mb']) * 1024 * 1024)
+        vcpus = str(instance_type['vcpus'])
+        rec = {
+            'name_label': instance.name,
+            'name_description': '',
+            'is_a_template': False,
+            'memory_static_min': '0',
+            'memory_static_max': mem,
+            'memory_dynamic_min': mem,
+            'memory_dynamic_max': mem,
+            'VCPUs_at_startup': vcpus,
+            'VCPUs_max': vcpus,
+            'VCPUs_params': {},
+            'actions_after_shutdown': 'destroy',
+            'actions_after_reboot': 'restart',
+            'actions_after_crash': 'destroy',
+            'PV_bootloader': '',
+            'PV_kernel': kernel,
+            'PV_ramdisk': ramdisk,
+            'PV_args': 'root=/dev/xvda1',
+            'PV_bootloader_args': '',
+            'PV_legacy_args': '',
+            'HVM_boot_policy': '',
+            'HVM_boot_params': {},
+            'platform': {},
+            'PCI_bus': '',
+            'recommendations': '',
+            'affinity': '',
+            'user_version': '0',
+            'other_config': {},
+            }
+        logging.debug('Created VM %s...', Instance.get_name(instance))
+        vm_ref = yield session.call_xenapi('VM.create', rec)
+        logging.debug('Created VM %s as %s.',
+                      Instance.get_name(instance), vm_ref)
+        defer.returnValue(vm_ref)
+
+    @classmethod
+    @defer.inlineCallbacks
+    def create_vbd(self, 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
+        vbd_rec['userdevice'] = str(userdevice)
+        vbd_rec['bootable'] = bootable
+        vbd_rec['mode'] = 'RW'
+        vbd_rec['type'] = 'disk'
+        vbd_rec['unpluggable'] = True
+        vbd_rec['empty'] = False
+        vbd_rec['other_config'] = {}
+        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)
+        vbd_ref = yield session.call_xenapi('VBD.create', vbd_rec)
+        logging.debug('Created VBD %s for VM %s, VDI %s.', vbd_ref, vm_ref,
+                      vdi_ref)
+        defer.returnValue(vbd_ref)
+
+    @classmethod
+    @defer.inlineCallbacks
+    def create_vif(self, 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
+        vif_rec['VM'] = vm_ref
+        vif_rec['MAC'] = mac_address
+        vif_rec['MTU'] = '1500'
+        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,
+                      network_ref)
+        vif_ref = yield session.call_xenapi('VIF.create', vif_rec)
+        logging.debug('Created VIF %s for VM %s, network %s.', vif_ref,
+                      vm_ref, network_ref)
+        defer.returnValue(vif_ref)
+
+    @classmethod
+    @defer.inlineCallbacks
+    def fetch_image(self, session, image, user, project, use_sr):
+        """use_sr: True to put the image as a VDI in an SR, False to place
+        it on dom0's filesystem.  The former is for VM disks, the latter for
+        its kernel and ramdisk (if external kernels are being used).
+        Returns a Deferred that gives the new VDI UUID."""
+
+        url = Image.get_url(image)
+        access = User.get_access(user, project)
+        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
+        args['username'] = access
+        args['password'] = User.get_secret(user)
+        if use_sr:
+            args['add_partition'] = 'true'
+        task = yield session.async_call_plugin('objectstore', fn, args)
+        uuid = yield session.wait_for_task(task)
+        defer.returnValue(uuid)
+
+    @classmethod
+    @utils.deferredToThread
+    def lookup(self, session, i):
+        return VMHelper.lookup_blocking(session, i)
+
+    @classmethod
+    def lookup_blocking(self, session, i):
+        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)
+        else:
+            return vms[0]
+
+    @classmethod
+    @utils.deferredToThread
+    def lookup_vm_vdis(self, session, vm):
+        return VMHelper.lookup_vm_vdis_blocking(session, vm)
+
+    @classmethod
+    def lookup_vm_vdis_blocking(self, session, vm):
+        # Firstly we get the VBDs, then the VDIs.
+        # TODO: do we leave the read-only devices?
+        vbds = session.get_xenapi().VM.get_VBDs(vm)
+        vdis = []
+        if vbds:
+            for vbd in vbds:
+                try:
+                    vdi = session.get_xenapi().VBD.get_VDI(vbd)
+                    # Test valid VDI
+                    record = session.get_xenapi().VDI.get_record(vdi)
+                except Exception, exc:
+                    logging.warn(exc)
+                else:
+                    vdis.append(vdi)
+            if len(vdis) > 0:
+                return vdis
+            else:
+                return None
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
new file mode 100644
index 000000000..d6ea5e7db
--- /dev/null
+++ b/nova/virt/xenapi/vmops.py
@@ -0,0 +1,123 @@
+# 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.
+
+"""
+Management class for VM-related functions (spawn, reboot, etc).
+"""
+
+import logging
+
+from twisted.internet import defer
+
+from novadeps import XENAPI_POWER_STATE
+from novadeps import Instance
+from novadeps import Network
+
+from vm_utils import VMHelper
+from network_utils import NetworkHelper
+
+
+class VMOps(object):
+    def __init__(self, session):
+        self._session = session
+
+    def list_instances(self):
+        return [self._session.get_xenapi().VM.get_name_label(vm) \
+                for vm in self._session.get_xenapi().VM.get_all()]
+
+    @defer.inlineCallbacks
+    def spawn(self, instance):
+        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
+        if vm is not None:
+            raise Exception('Attempted to create non-unique name %s' %
+                            Instance.get_name(instance))
+
+        bridge = Network.get_bridge(Instance.get_network(instance))
+        network_ref = \
+            yield NetworkHelper.find_network_with_bridge(self._session, bridge)
+
+        user = Instance.get_user(instance)
+        project = Instance.get_project(instance)
+        vdi_uuid = yield VMHelper.fetch_image(self._session,
+            Instance.get_image_id(instance), user, project, True)
+        kernel = yield VMHelper.fetch_image(self._session,
+            Instance.get_kernel_id(instance), user, project, False)
+        ramdisk = yield VMHelper.fetch_image(self._session,
+            Instance.get_ramdisk_id(instance), user, project, False)
+        vdi_ref = yield self._session.call_xenapi('VDI.get_by_uuid', vdi_uuid)
+        vm_ref = yield VMHelper.create_vm(self._session,
+                                          instance, kernel, ramdisk)
+        yield VMHelper.create_vbd(self._session, vm_ref, vdi_ref, 0, True)
+        if network_ref:
+            yield VMHelper.create_vif(self._session, vm_ref,
+                                      network_ref, Instance.get_mac(instance))
+        logging.debug('Starting VM %s...', vm_ref)
+        yield self._session.call_xenapi('VM.start', vm_ref, False, False)
+        logging.info('Spawning VM %s created %s.', Instance.get_name(instance),
+                     vm_ref)
+
+    @defer.inlineCallbacks
+    def reboot(self, instance):
+        instance_name = Instance.get_name(instance)
+        vm = yield VMHelper.lookup(self._session, instance_name)
+        if vm is None:
+            raise Exception('instance not present %s' % instance_name)
+        task = yield self._session.call_xenapi('Async.VM.clean_reboot', vm)
+        yield self._session.wait_for_task(task)
+
+    @defer.inlineCallbacks
+    def destroy(self, instance):
+        vm = yield VMHelper.lookup(self._session, Instance.get_name(instance))
+        if vm is None:
+            # Don't complain, just return.  This lets us clean up instances
+            # that have already disappeared from the underlying platform.
+            defer.returnValue(None)
+        # Get the VDIs related to the VM
+        vdis = yield VMHelper.lookup_vm_vdis(self._session, vm)
+        try:
+            task = yield self._session.call_xenapi('Async.VM.hard_shutdown',
+                                                   vm)
+            yield self._session.wait_for_task(task)
+        except Exception, exc:
+            logging.warn(exc)
+        # Disk clean-up
+        if vdis:
+            for vdi in vdis:
+                try:
+                    task = yield self._session.call_xenapi('Async.VDI.destroy',
+                                                           vdi)
+                    yield self._session.wait_for_task(task)
+                except Exception, exc:
+                    logging.warn(exc)
+        try:
+            task = yield self._session.call_xenapi('Async.VM.destroy', vm)
+            yield self._session.wait_for_task(task)
+        except Exception, exc:
+            logging.warn(exc)
+
+    def get_info(self, instance_id):
+        vm = VMHelper.lookup_blocking(self._session, instance_id)
+        if vm is None:
+            raise Exception('instance not present %s' % instance_id)
+        rec = self._session.get_xenapi().VM.get_record(vm)
+        return {'state': XENAPI_POWER_STATE[rec['power_state']],
+                'max_mem': long(rec['memory_static_max']) >> 10,
+                'mem': long(rec['memory_dynamic_max']) >> 10,
+                'num_cpu': rec['VCPUs_max'],
+                'cpu_time': 0}
+
+    def get_console_output(self, instance):
+        return 'FAKE CONSOLE OUTPUT'
diff --git a/nova/virt/xenapi/volumeops.py b/nova/virt/xenapi/volumeops.py
new file mode 100644
index 000000000..23f79adf7
--- /dev/null
+++ b/nova/virt/xenapi/volumeops.py
@@ -0,0 +1,30 @@
+# 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.
+
+"""
+Management class for Storage-related functions (attach, detach, etc).
+"""
+
+
+class VolumeOps(object):
+    def __init__(self, session):
+        self._session = session
+
+    def attach_volume(self, instance_name, device_path, mountpoint):
+        return True
+
+    def detach_volume(self, instance_name, mountpoint):
+        return True
diff --git a/nova/virt/xenapi_conn.py b/nova/virt/xenapi_conn.py
new file mode 100644
index 000000000..0a73b4774
--- /dev/null
+++ b/nova/virt/xenapi_conn.py
@@ -0,0 +1,227 @@
+# 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.
+
+"""
+A connection to XenServer or Xen Cloud Platform.
+
+The concurrency model for this class is as follows:
+
+All XenAPI calls are on a thread (using t.i.t.deferToThread, via the decorator
+deferredToThread).  They are remote calls, and so may hang for the usual
+reasons.  They should not be allowed to block the reactor thread.
+
+All long-running XenAPI calls (VM.start, VM.reboot, etc) are called async
+(using XenAPI.VM.async_start etc).  These return a task, which can then be
+polled for completion.  Polling is handled using reactor.callLater.
+
+This combination of techniques means that we don't block the reactor thread at
+all, and at the same time we don't hold lots of threads waiting for
+long-running operations.
+
+FIXME: get_info currently doesn't conform to these rules, and will block the
+reactor thread if the VM.get_by_name_label or VM.get_record calls block.
+
+**Related Flags**
+
+:xenapi_connection_url:  URL for connection to XenServer/Xen Cloud Platform.
+:xenapi_connection_username:  Username for connection to XenServer/Xen Cloud
+                              Platform (default: root).
+:xenapi_connection_password:  Password for connection to XenServer/Xen Cloud
+                              Platform.
+:xenapi_task_poll_interval:  The interval (seconds) used for polling of
+                             remote tasks (Async.VM.start, etc)
+                             (default: 0.5).
+
+"""
+
+import logging
+import xmlrpclib
+
+from twisted.internet import defer
+from twisted.internet import reactor
+
+from nova import flags
+from nova import utils
+
+from xenapi.vmops import VMOps
+from xenapi.volumeops import VolumeOps
+
+XenAPI = None
+
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('xenapi_connection_url',
+                    None,
+                    'URL for connection to XenServer/Xen Cloud Platform.'
+                    ' Required if connection_type=xenapi.')
+flags.DEFINE_string('xenapi_connection_username',
+                    'root',
+                    'Username for connection to XenServer/Xen Cloud Platform.'
+                    ' Used only if connection_type=xenapi.')
+flags.DEFINE_string('xenapi_connection_password',
+                    None,
+                    'Password for connection to XenServer/Xen Cloud Platform.'
+                    ' Used only if connection_type=xenapi.')
+flags.DEFINE_float('xenapi_task_poll_interval',
+                   0.5,
+                   'The interval used for polling of remote tasks '
+                   '(Async.VM.start, etc).  Used only if '
+                   'connection_type=xenapi.')
+
+
+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
+    if not url or password is None:
+        raise Exception('Must specify xenapi_connection_url, '
+                        'xenapi_connection_username (optionally), and '
+                        'xenapi_connection_password to use '
+                        'connection_type=xenapi')
+    return XenAPIConnection(url, username, password)
+
+
+class XenAPIConnection(object):
+    def __init__(self, url, user, pw):
+        session = XenAPISession(url, user, pw)
+        self._vmops = VMOps(session)
+        self._volumeops = VolumeOps(session)
+
+    def list_instances(self):
+        return self._vmops.list_instances()
+
+    def spawn(self, instance):
+        self._vmops.spawn(instance)
+
+    def reboot(self, instance):
+        self._vmops.reboot(instance)
+
+    def destroy(self, instance):
+        self._vmops.destroy(instance)
+
+    def get_info(self, instance_id):
+        return self._vmops.get_info(instance_id)
+
+    def get_console_output(self, instance):
+        return self._vmops.get_console_output(instance)
+
+    def attach_volume(self, instance_name, device_path, mountpoint):
+        return self._volumeops.attach_volume(instance_name,
+                                               device_path,
+                                               mountpoint)
+
+    def detach_volume(self, instance_name, mountpoint):
+        return self._volumeops.detach_volume(instance_name, mountpoint)
+
+
+class XenAPISession(object):
+    def __init__(self, url, user, pw):
+        self._session = XenAPI.Session(url)
+        self._session.login_with_password(user, pw)
+
+    def get_xenapi(self):
+        return self._session.xenapi
+
+    def get_xenapi_host(self):
+        return self._session.xenapi.session.get_this_host(self._session.handle)
+
+    @utils.deferredToThread
+    def call_xenapi(self, method, *args):
+        """Call the specified XenAPI method on a background thread.  Returns
+        a Deferred for the result."""
+        f = self._session.xenapi
+        for m in method.split('.'):
+            f = f.__getattr__(m)
+        return f(*args)
+
+    @utils.deferredToThread
+    def async_call_plugin(self, plugin, fn, args):
+        """Call Async.host.call_plugin on a background thread.  Returns a
+        Deferred with the task reference."""
+        return _unwrap_plugin_exceptions(
+            self._session.xenapi.Async.host.call_plugin,
+            self.get_xenapi_host(), plugin, fn, args)
+
+    def wait_for_task(self, task):
+        """Return a Deferred that will give the result of the given task.
+        The task is polled until it completes."""
+        d = defer.Deferred()
+        reactor.callLater(0, self._poll_task, task, d)
+        return d
+
+    @utils.deferredToThread
+    def _poll_task(self, task, deferred):
+        """Poll the given XenAPI task, and fire the given Deferred if we
+        get a result."""
+        try:
+            #logging.debug('Polling task %s...', task)
+            status = self._session.xenapi.task.get_status(task)
+            if status == 'pending':
+                reactor.callLater(FLAGS.xenapi_task_poll_interval,
+                                  self._poll_task, task, deferred)
+            elif status == 'success':
+                result = self._session.xenapi.task.get_result(task)
+                logging.info('Task %s status: success.  %s', task, result)
+                deferred.callback(_parse_xmlrpc_value(result))
+            else:
+                error_info = self._session.xenapi.task.get_error_info(task)
+                logging.warn('Task %s status: %s.  %s', task, status,
+                             error_info)
+                deferred.errback(XenAPI.Failure(error_info))
+            #logging.debug('Polling task %s done.', task)
+        except Exception, exc:
+            logging.warn(exc)
+            deferred.errback(exc)
+
+
+def _unwrap_plugin_exceptions(func, *args, **kwargs):
+    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:
+            raise
+    except xmlrpclib.ProtocolError, exc:
+        logging.debug("Got exception: %s", exc)
+        raise
+
+
+def _parse_xmlrpc_value(val):
+    """Parse the given value as if it were an XML-RPC value.  This is
+    sometimes used as the format for the task.result field."""
+    if not val:
+        return val
+    x = xmlrpclib.loads(
+        '<?xml version="1.0"?><methodResponse><params><param>' +
+        val +
+        '</param></params></methodResponse>')
+    return x[0][0]
-- 
cgit