merge trunk

20 files changed, 3674 insertions, 177 deletions

diff --git a/nova/virt/connection.py b/nova/virt/connection.py
index af7001715..99a8849f1 100644
--- a/nova/virt/connection.py
+++ b/nova/virt/connection.py
@@ -26,9 +26,10 @@ from nova import log as logging
 from nova import utils
 from nova.virt import driver
 from nova.virt import fake
+from nova.virt import hyperv
 from nova.virt import libvirt_conn
+from nova.virt import vmwareapi_conn
 from nova.virt import xenapi_conn
-from nova.virt import hyperv
 
 
 LOG = logging.getLogger("nova.virt.connection")
@@ -68,6 +69,8 @@ def get_connection(read_only=False):
         conn = xenapi_conn.get_connection(read_only)
     elif t == 'hyperv':
         conn = hyperv.get_connection(read_only)
+    elif t == 'vmwareapi':
+        conn = vmwareapi_conn.get_connection(read_only)
     else:
         raise Exception('Unknown connection type "%s"' % t)
 
diff --git a/nova/virt/driver.py b/nova/virt/driver.py
index 0e3a4aa3b..f9cf1b8aa 100644
--- a/nova/virt/driver.py
+++ b/nova/virt/driver.py
@@ -61,7 +61,7 @@ class ComputeDriver(object):
         """Return a list of InstanceInfo for all registered VMs"""
         raise NotImplementedError()
 
-    def spawn(self, instance):
+    def spawn(self, instance, network_info=None):
         """Launch a VM for the specified instance"""
         raise NotImplementedError()
 
diff --git a/nova/virt/fake.py b/nova/virt/fake.py
index 5b0fe1877..7018f8c1b 100644
--- a/nova/virt/fake.py
+++ b/nova/virt/fake.py
@@ -344,7 +344,7 @@ class FakeConnection(driver.ComputeDriver):
         Note that this function takes an instance ID, not a
         compute.service.Instance, so that it can be called by compute.monitor.
         """
-        return [0L, 0L, 0L, 0L, null]
+        return [0L, 0L, 0L, 0L, None]
 
     def interface_stats(self, instance_name, iface_id):
         """
diff --git a/nova/virt/interfaces.template b/nova/virt/interfaces.template
index 3b34e54f4..e527cf35c 100644
--- a/nova/virt/interfaces.template
+++ b/nova/virt/interfaces.template
@@ -5,19 +5,20 @@
 auto lo
 iface lo inet loopback
 
-# The primary network interface
-auto eth0
-iface eth0 inet static
-        address ${address}
-        netmask ${netmask}
-        broadcast ${broadcast}
-        gateway ${gateway}
-        dns-nameservers ${dns}
+#for $ifc in $interfaces
+auto ${ifc.name}
+iface ${ifc.name} inet static
+        address ${ifc.address}
+        netmask ${ifc.netmask}
+        broadcast ${ifc.broadcast}
+        gateway ${ifc.gateway}
+        dns-nameservers ${ifc.dns}
 
 #if $use_ipv6
-iface eth0 inet6 static
-    address ${address_v6}
-    netmask ${netmask_v6}
-    gateway ${gateway_v6}
+iface ${ifc.name} inet6 static
+    address ${ifc.address_v6}
+    netmask ${ifc.netmask_v6}
+    gateway ${ifc.gateway_v6}
 #end if
 
+#end for
diff --git a/nova/virt/libvirt.xml.template b/nova/virt/libvirt.xml.template
index ef2d2cd6b..d74a9e85b 100644
--- a/nova/virt/libvirt.xml.template
+++ b/nova/virt/libvirt.xml.template
@@ -69,21 +69,24 @@
         </disk>
     #end if
 #end if
+
+#for $nic in $nics
         <interface type='bridge'>
-            <source bridge='${bridge_name}'/>
-            <mac address='${mac_address}'/>
+            <source bridge='${nic.bridge_name}'/>
+            <mac address='${nic.mac_address}'/>
             <!--   <model type='virtio'/>  CANT RUN virtio network right now -->
-            <filterref filter="nova-instance-${name}">
-                <parameter name="IP" value="${ip_address}" />
-                <parameter name="DHCPSERVER" value="${dhcp_server}" />           
-#if $getVar('extra_params', False)
-                ${extra_params}
+            <filterref filter="nova-instance-${name}-${nic.id}">
+                <parameter name="IP" value="${nic.ip_address}" />
+                <parameter name="DHCPSERVER" value="${nic.dhcp_server}" />
+#if $getVar('nic.extra_params', False)
+                ${nic.extra_params}
 #end if
-#if $getVar('gateway_v6', False)
-                <parameter name="RASERVER" value="${gateway_v6}" />
+#if $getVar('nic.gateway_v6', False)
+                <parameter name="RASERVER" value="${nic.gateway_v6}" />
 #end if
             </filterref>
         </interface>
+#end for
 
         <!-- The order is significant here.  File must be defined first -->
         <serial type="file">
diff --git a/nova/virt/libvirt_conn.py b/nova/virt/libvirt_conn.py
index e1a0a6f29..2cecb010d 100644
--- a/nova/virt/libvirt_conn.py
+++ b/nova/virt/libvirt_conn.py
@@ -153,6 +153,51 @@ def _get_ip_version(cidr):
         return int(net.version())
 
 
+def _get_network_info(instance):
+    # TODO(adiantum) If we will keep this function
+    # we should cache network_info
+    admin_context = context.get_admin_context()
+
+    ip_addresses = db.fixed_ip_get_all_by_instance(admin_context,
+                                                   instance['id'])
+
+    networks = db.network_get_all_by_instance(admin_context,
+                                              instance['id'])
+    network_info = []
+
+    def ip_dict(ip):
+        return {
+            "ip": ip.address,
+            "netmask": network["netmask"],
+            "enabled": "1"}
+
+    def ip6_dict(ip6):
+        prefix = ip6.network.cidr_v6
+        mac = instance.mac_address
+        return  {
+            "ip": utils.to_global_ipv6(prefix, mac),
+            "netmask": ip6.network.netmask_v6,
+            "gateway": ip6.network.gateway_v6,
+            "enabled": "1"}
+
+    for network in networks:
+        network_ips = [ip for ip in ip_addresses
+                       if ip.network_id == network.id]
+
+        mapping = {
+            'label': network['label'],
+            'gateway': network['gateway'],
+            'mac': instance.mac_address,
+            'dns': [network['dns']],
+            'ips': [ip_dict(ip) for ip in network_ips]}
+
+        if FLAGS.use_ipv6:
+            mapping['ip6s'] = [ip6_dict(ip) for ip in network_ips]
+
+        network_info.append((network, mapping))
+    return network_info
+
+
 class LibvirtConnection(driver.ComputeDriver):
 
     def __init__(self, read_only):
@@ -444,16 +489,18 @@ class LibvirtConnection(driver.ComputeDriver):
     def poll_rescued_instances(self, timeout):
         pass
 
+    # NOTE(ilyaalekseyev): Implementation like in multinics
+    # for xenapi(tr3buchet)
     @exception.wrap_exception
-    def spawn(self, instance):
-        xml = self.to_xml(instance)
+    def spawn(self, instance, network_info=None):
+        xml = self.to_xml(instance, network_info)
         db.instance_set_state(context.get_admin_context(),
                               instance['id'],
                               power_state.NOSTATE,
                               'launching')
-        self.firewall_driver.setup_basic_filtering(instance)
-        self.firewall_driver.prepare_instance_filter(instance)
-        self._create_image(instance, xml)
+        self.firewall_driver.setup_basic_filtering(instance, network_info)
+        self.firewall_driver.prepare_instance_filter(instance, network_info)
+        self._create_image(instance, xml, network_info)
         self._conn.createXML(xml, 0)
         LOG.debug(_("instance %s: is running"), instance['name'])
         self.firewall_driver.apply_instance_filter(instance)
@@ -609,7 +656,14 @@ class LibvirtConnection(driver.ComputeDriver):
         utils.execute('truncate', target, '-s', "%dG" % local_gb)
         # TODO(vish): should we format disk by default?
 
-    def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None):
+    def _create_image(self, inst, libvirt_xml, suffix='', disk_images=None,
+                        network_info=None):
+        if not network_info:
+            network_info = _get_network_info(inst)
+
+        if not suffix:
+            suffix = ''
+
         # syntactic nicety
         def basepath(fname='', suffix=suffix):
             return os.path.join(FLAGS.instances_path,
@@ -685,28 +739,35 @@ class LibvirtConnection(driver.ComputeDriver):
 
         key = str(inst['key_data'])
         net = None
-        network_ref = db.network_get_by_instance(context.get_admin_context(),
-                                                 inst['id'])
-        if network_ref['injected']:
-            admin_context = context.get_admin_context()
-            address = db.instance_get_fixed_address(admin_context, inst['id'])
+
+        nets = []
+        ifc_template = open(FLAGS.injected_network_template).read()
+        ifc_num = -1
+        admin_context = context.get_admin_context()
+        for (network_ref, mapping) in network_info:
+            ifc_num += 1
+
+            if not 'injected' in network_ref:
+                continue
+
+            address = mapping['ips'][0]['ip']
             address_v6 = None
             if FLAGS.use_ipv6:
-                address_v6 = db.instance_get_fixed_address_v6(admin_context,
-                                                              inst['id'])
-
-            interfaces_info = {'address': address,
-                               'netmask': network_ref['netmask'],
-                               'gateway': network_ref['gateway'],
-                               'broadcast': network_ref['broadcast'],
-                               'dns': network_ref['dns'],
-                               'address_v6': address_v6,
-                               'gateway_v6': network_ref['gateway_v6'],
-                               'netmask_v6': network_ref['netmask_v6'],
-                               'use_ipv6': FLAGS.use_ipv6}
-
-            net = str(Template(self.interfaces_xml,
-                                searchList=[interfaces_info]))
+                address_v6 = mapping['ip6s'][0]['ip']
+            net_info = {'name': 'eth%d' % ifc_num,
+                   'address': address,
+                   'netmask': network_ref['netmask'],
+                   'gateway': network_ref['gateway'],
+                   'broadcast': network_ref['broadcast'],
+                   'dns': network_ref['dns'],
+                   'address_v6': address_v6,
+                   'gateway_v6': network_ref['gateway_v6'],
+                   'netmask_v6': network_ref['netmask_v6'],
+                   'use_ipv6': FLAGS.use_ipv6}
+            nets.append(net_info)
+
+        net = str(Template(ifc_template, searchList=[{'interfaces': nets}]))
+
         if key or net:
             inst_name = inst['name']
             img_id = inst.image_id
@@ -728,20 +789,11 @@ class LibvirtConnection(driver.ComputeDriver):
         if FLAGS.libvirt_type == 'uml':
             utils.execute('sudo', 'chown', 'root', basepath('disk'))
 
-    def to_xml(self, instance, rescue=False):
-        # TODO(termie): cache?
-        LOG.debug(_('instance %s: starting toXML method'), instance['name'])
-        network = db.network_get_by_instance(context.get_admin_context(),
-                                             instance['id'])
-        # FIXME(vish): stick this in db
-        instance_type = instance['instance_type']
-        # instance_type = test.INSTANCE_TYPES[instance_type]
-        instance_type = instance_types.get_instance_type(instance_type)
-        ip_address = db.instance_get_fixed_address(context.get_admin_context(),
-                                                   instance['id'])
+    def _get_nic_for_xml(self, network, mapping):
         # Assume that the gateway also acts as the dhcp server.
         dhcp_server = network['gateway']
         gateway_v6 = network['gateway_v6']
+        mac_id = mapping['mac'].replace(':', '')
 
         if FLAGS.allow_project_net_traffic:
             if FLAGS.use_ipv6:
@@ -766,6 +818,38 @@ class LibvirtConnection(driver.ComputeDriver):
                               (net, mask)
         else:
             extra_params = "\n"
+
+        result = {
+            'id': mac_id,
+            'bridge_name': network['bridge'],
+            'mac_address': mapping['mac'],
+            'ip_address': mapping['ips'][0]['ip'],
+            'dhcp_server': dhcp_server,
+            'extra_params': extra_params,
+        }
+
+        if gateway_v6:
+            result['gateway_v6'] = gateway_v6 + "/128"
+
+        return result
+
+    def to_xml(self, instance, rescue=False, network_info=None):
+        # TODO(termie): cache?
+        LOG.debug(_('instance %s: starting toXML method'), instance['name'])
+
+        # TODO(adiantum) remove network_info creation code
+        # when multinics will be completed
+        if not network_info:
+            network_info = _get_network_info(instance)
+
+        nics = []
+        for (network, mapping) in network_info:
+            nics.append(self._get_nic_for_xml(network,
+                                              mapping))
+        # FIXME(vish): stick this in db
+        instance_type_name = instance['instance_type']
+        instance_type = instance_types.get_instance_type(instance_type_name)
+
         if FLAGS.use_cow_images:
             driver_type = 'qcow2'
         else:
@@ -777,17 +861,11 @@ class LibvirtConnection(driver.ComputeDriver):
                                              instance['name']),
                     'memory_kb': instance_type['memory_mb'] * 1024,
                     'vcpus': instance_type['vcpus'],
-                    'bridge_name': network['bridge'],
-                    'mac_address': instance['mac_address'],
-                    'ip_address': ip_address,
-                    'dhcp_server': dhcp_server,
-                    'extra_params': extra_params,
                     'rescue': rescue,
                     'local': instance_type['local_gb'],
-                    'driver_type': driver_type}
+                    'driver_type': driver_type,
+                    'nics': nics}
 
-        if gateway_v6:
-            xml_info['gateway_v6'] = gateway_v6 + "/128"
         if not rescue:
             if instance['kernel_id']:
                 xml_info['kernel'] = xml_info['basepath'] + "/kernel"
@@ -800,7 +878,6 @@ class LibvirtConnection(driver.ComputeDriver):
         xml = str(Template(self.libvirt_xml, searchList=[xml_info]))
         LOG.debug(_('instance %s: finished toXML method'),
                         instance['name'])
-
         return xml
 
     def get_info(self, instance_name):
@@ -1008,7 +1085,18 @@ class LibvirtConnection(driver.ComputeDriver):
 
         """
 
-        return self._conn.getVersion()
+        # NOTE(justinsb): getVersion moved between libvirt versions
+        # Trying to do be compatible with older versions is a lost cause
+        # But ... we can at least give the user a nice message
+        method = getattr(self._conn, 'getVersion', None)
+        if method is None:
+            raise exception.Error(_("libvirt version is too old"
+                                    " (does not support getVersion)"))
+            # NOTE(justinsb): If we wanted to get the version, we could:
+            # method = getattr(libvirt, 'getVersion', None)
+            # NOTE(justinsb): This would then rely on a proper version check
+
+        return method()
 
     def get_cpu_info(self):
         """Get cpuinfo information.
@@ -1305,7 +1393,7 @@ class LibvirtConnection(driver.ComputeDriver):
 
 
 class FirewallDriver(object):
-    def prepare_instance_filter(self, instance):
+    def prepare_instance_filter(self, instance, network_info=None):
         """Prepare filters for the instance.
 
         At this point, the instance isn't running yet."""
@@ -1339,7 +1427,7 @@ class FirewallDriver(object):
         the security group."""
         raise NotImplementedError()
 
-    def setup_basic_filtering(self, instance):
+    def setup_basic_filtering(self, instance, network_info=None):
         """Create rules to block spoofing and allow dhcp.
 
         This gets called when spawning an instance, before
@@ -1348,11 +1436,6 @@ class FirewallDriver(object):
         """
         raise NotImplementedError()
 
-    def _gateway_v6_for_instance(self, instance):
-        network = db.network_get_by_instance(context.get_admin_context(),
-                                             instance['id'])
-        return network['gateway_v6']
-
 
 class NWFilterFirewall(FirewallDriver):
     """
@@ -1444,10 +1527,13 @@ class NWFilterFirewall(FirewallDriver):
                               </rule>
                             </filter>'''
 
-    def setup_basic_filtering(self, instance):
+    def setup_basic_filtering(self, instance, network_info=None):
         """Set up basic filtering (MAC, IP, and ARP spoofing protection)"""
         logging.info('called setup_basic_filtering in nwfilter')
 
+        if not network_info:
+            network_info = _get_network_info(instance)
+
         if self.handle_security_groups:
             # No point in setting up a filter set that we'll be overriding
             # anyway.
@@ -1456,9 +1542,11 @@ class NWFilterFirewall(FirewallDriver):
         logging.info('ensuring static filters')
         self._ensure_static_filters()
 
-        instance_filter_name = self._instance_filter_name(instance)
-        self._define_filter(self._filter_container(instance_filter_name,
-                                                   ['nova-base']))
+        for (network, mapping) in network_info:
+            nic_id = mapping['mac'].replace(':', '')
+            instance_filter_name = self._instance_filter_name(instance, nic_id)
+            self._define_filter(self._filter_container(instance_filter_name,
+                                                       ['nova-base']))
 
     def _ensure_static_filters(self):
         if self.static_filters_configured:
@@ -1549,48 +1637,60 @@ class NWFilterFirewall(FirewallDriver):
         # Nothing to do
         pass
 
-    def prepare_instance_filter(self, instance):
+    def prepare_instance_filter(self, instance, network_info=None):
         """
         Creates an NWFilter for the given instance. In the process,
         it makes sure the filters for the security groups as well as
         the base filter are all in place.
         """
+        if not network_info:
+            network_info = _get_network_info(instance)
         if instance['image_id'] == FLAGS.vpn_image_id:
             base_filter = 'nova-vpn'
         else:
             base_filter = 'nova-base'
 
-        instance_filter_name = self._instance_filter_name(instance)
-        instance_secgroup_filter_name = '%s-secgroup' % (instance_filter_name,)
-        instance_filter_children = [base_filter, instance_secgroup_filter_name]
+        ctxt = context.get_admin_context()
+
+        instance_secgroup_filter_name = \
+            '%s-secgroup' % (self._instance_filter_name(instance))
+            #% (instance_filter_name,)
+
         instance_secgroup_filter_children = ['nova-base-ipv4',
                                              'nova-base-ipv6',
                                              'nova-allow-dhcp-server']
-        if FLAGS.use_ipv6:
-            gateway_v6 = self._gateway_v6_for_instance(instance)
-            if gateway_v6:
-                instance_secgroup_filter_children += ['nova-allow-ra-server']
-
-        ctxt = context.get_admin_context()
-
-        if FLAGS.allow_project_net_traffic:
-            instance_filter_children += ['nova-project']
-            if FLAGS.use_ipv6:
-                instance_filter_children += ['nova-project-v6']
 
-        for security_group in db.security_group_get_by_instance(ctxt,
-                                                               instance['id']):
+        for security_group in \
+                db.security_group_get_by_instance(ctxt, instance['id']):
 
             self.refresh_security_group_rules(security_group['id'])
 
             instance_secgroup_filter_children += [('nova-secgroup-%s' %
-                                                         security_group['id'])]
+                                                    security_group['id'])]
 
-        self._define_filter(
+            self._define_filter(
                     self._filter_container(instance_secgroup_filter_name,
                                            instance_secgroup_filter_children))
 
-        self._define_filter(
+        for (network, mapping) in network_info:
+            nic_id = mapping['mac'].replace(':', '')
+            instance_filter_name = self._instance_filter_name(instance, nic_id)
+            instance_filter_children = \
+                [base_filter, instance_secgroup_filter_name]
+
+            if FLAGS.use_ipv6:
+                gateway_v6 = network['gateway_v6']
+
+                if gateway_v6:
+                    instance_secgroup_filter_children += \
+                        ['nova-allow-ra-server']
+
+            if FLAGS.allow_project_net_traffic:
+                instance_filter_children += ['nova-project']
+                if FLAGS.use_ipv6:
+                    instance_filter_children += ['nova-project-v6']
+
+            self._define_filter(
                     self._filter_container(instance_filter_name,
                                            instance_filter_children))
 
@@ -1638,8 +1738,10 @@ class NWFilterFirewall(FirewallDriver):
             xml += "chain='ipv4'>%s</filter>" % rule_xml
         return xml
 
-    def _instance_filter_name(self, instance):
-        return 'nova-instance-%s' % instance['name']
+    def _instance_filter_name(self, instance, nic_id=None):
+        if not nic_id:
+            return 'nova-instance-%s' % (instance['name'])
+        return 'nova-instance-%s-%s' % (instance['name'], nic_id)
 
 
 class IptablesFirewallDriver(FirewallDriver):
@@ -1654,9 +1756,11 @@ class IptablesFirewallDriver(FirewallDriver):
         self.iptables.ipv6['filter'].add_chain('sg-fallback')
         self.iptables.ipv6['filter'].add_rule('sg-fallback', '-j DROP')
 
-    def setup_basic_filtering(self, instance):
+    def setup_basic_filtering(self, instance, network_info=None):
         """Use NWFilter from libvirt for this."""
-        return self.nwfilter.setup_basic_filtering(instance)
+        if not network_info:
+            network_info = _get_network_info(instance)
+        return self.nwfilter.setup_basic_filtering(instance, network_info)
 
     def apply_instance_filter(self, instance):
         """No-op. Everything is done in prepare_instance_filter"""
@@ -1670,29 +1774,40 @@ class IptablesFirewallDriver(FirewallDriver):
             LOG.info(_('Attempted to unfilter instance %s which is not '
                      'filtered'), instance['id'])
 
-    def prepare_instance_filter(self, instance):
+    def prepare_instance_filter(self, instance, network_info=None):
+        if not network_info:
+            network_info = _get_network_info(instance)
         self.instances[instance['id']] = instance
-        self.add_filters_for_instance(instance)
+        self.add_filters_for_instance(instance, network_info)
         self.iptables.apply()
 
-    def add_filters_for_instance(self, instance):
+    def add_filters_for_instance(self, instance, network_info=None):
+        if not network_info:
+            network_info = _get_network_info(instance)
         chain_name = self._instance_chain_name(instance)
 
         self.iptables.ipv4['filter'].add_chain(chain_name)
-        ipv4_address = self._ip_for_instance(instance)
-        self.iptables.ipv4['filter'].add_rule('local',
-                                              '-d %s -j $%s' %
-                                              (ipv4_address, chain_name))
+
+        ips_v4 = [ip['ip'] for (_, mapping) in network_info
+                            for ip in mapping['ips']]
+
+        for ipv4_address in ips_v4:
+            self.iptables.ipv4['filter'].add_rule('local',
+                                                  '-d %s -j $%s' %
+                                                  (ipv4_address, chain_name))
 
         if FLAGS.use_ipv6:
             self.iptables.ipv6['filter'].add_chain(chain_name)
-            ipv6_address = self._ip_for_instance_v6(instance)
-            self.iptables.ipv6['filter'].add_rule('local',
-                                                  '-d %s -j $%s' %
-                                                  (ipv6_address,
-                                                   chain_name))
+            ips_v6 = [ip['ip'] for (_, mapping) in network_info
+                                 for ip in mapping['ip6s']]
+
+            for ipv6_address in ips_v6:
+                self.iptables.ipv6['filter'].add_rule('local',
+                                                      '-d %s -j $%s' %
+                                                      (ipv6_address,
+                                                       chain_name))
 
-        ipv4_rules, ipv6_rules = self.instance_rules(instance)
+        ipv4_rules, ipv6_rules = self.instance_rules(instance, network_info)
 
         for rule in ipv4_rules:
             self.iptables.ipv4['filter'].add_rule(chain_name, rule)
@@ -1708,7 +1823,9 @@ class IptablesFirewallDriver(FirewallDriver):
         if FLAGS.use_ipv6:
             self.iptables.ipv6['filter'].remove_chain(chain_name)
 
-    def instance_rules(self, instance):
+    def instance_rules(self, instance, network_info=None):
+        if not network_info:
+            network_info = _get_network_info(instance)
         ctxt = context.get_admin_context()
 
         ipv4_rules = []
@@ -1722,28 +1839,36 @@ class IptablesFirewallDriver(FirewallDriver):
         ipv4_rules += ['-m state --state ESTABLISHED,RELATED -j ACCEPT']
         ipv6_rules += ['-m state --state ESTABLISHED,RELATED -j ACCEPT']
 
-        dhcp_server = self._dhcp_server_for_instance(instance)
-        ipv4_rules += ['-s %s -p udp --sport 67 --dport 68 '
-                       '-j ACCEPT' % (dhcp_server,)]
+        dhcp_servers = [network['gateway'] for (network, _m) in network_info]
+
+        for dhcp_server in dhcp_servers:
+            ipv4_rules.append('-s %s -p udp --sport 67 --dport 68 '
+                              '-j ACCEPT' % (dhcp_server,))
 
         #Allow project network traffic
         if FLAGS.allow_project_net_traffic:
-            cidr = self._project_cidr_for_instance(instance)
-            ipv4_rules += ['-s %s -j ACCEPT' % (cidr,)]
+            cidrs = [network['cidr'] for (network, _m) in network_info]
+            for cidr in cidrs:
+                ipv4_rules.append('-s %s -j ACCEPT' % (cidr,))
 
         # We wrap these in FLAGS.use_ipv6 because they might cause
         # a DB lookup. The other ones are just list operations, so
         # they're not worth the clutter.
         if FLAGS.use_ipv6:
             # Allow RA responses
-            gateway_v6 = self._gateway_v6_for_instance(instance)
-            if gateway_v6:
-                ipv6_rules += ['-s %s/128 -p icmpv6 -j ACCEPT' % (gateway_v6,)]
+            gateways_v6 = [network['gateway_v6'] for (network, _) in
+                           network_info]
+            for gateway_v6 in gateways_v6:
+                ipv6_rules.append(
+                        '-s %s/128 -p icmpv6 -j ACCEPT' % (gateway_v6,))
 
             #Allow project network traffic
             if FLAGS.allow_project_net_traffic:
-                cidrv6 = self._project_cidrv6_for_instance(instance)
-                ipv6_rules += ['-s %s -j ACCEPT' % (cidrv6,)]
+                cidrv6s = [network['cidr_v6'] for (network, _m)
+                          in network_info]
+
+                for cidrv6 in cidrv6s:
+                    ipv6_rules.append('-s %s -j ACCEPT' % (cidrv6,))
 
         security_groups = db.security_group_get_by_instance(ctxt,
                                                             instance['id'])
@@ -1825,31 +1950,3 @@ class IptablesFirewallDriver(FirewallDriver):
 
     def _instance_chain_name(self, instance):
         return 'inst-%s' % (instance['id'],)
-
-    def _ip_for_instance(self, instance):
-        return db.instance_get_fixed_address(context.get_admin_context(),
-                                             instance['id'])
-
-    def _ip_for_instance_v6(self, instance):
-        return db.instance_get_fixed_address_v6(context.get_admin_context(),
-                                             instance['id'])
-
-    def _dhcp_server_for_instance(self, instance):
-        network = db.network_get_by_instance(context.get_admin_context(),
-                                             instance['id'])
-        return network['gateway']
-
-    def _gateway_v6_for_instance(self, instance):
-        network = db.network_get_by_instance(context.get_admin_context(),
-                                             instance['id'])
-        return network['gateway_v6']
-
-    def _project_cidr_for_instance(self, instance):
-        network = db.network_get_by_instance(context.get_admin_context(),
-                                             instance['id'])
-        return network['cidr']
-
-    def _project_cidrv6_for_instance(self, instance):
-        network = db.network_get_by_instance(context.get_admin_context(),
-                                             instance['id'])
-        return network['cidr_v6']
diff --git a/nova/virt/vmwareapi/__init__.py b/nova/virt/vmwareapi/__init__.py
new file mode 100644
index 000000000..d9b27de08
--- /dev/null
+++ b/nova/virt/vmwareapi/__init__.py
@@ -0,0 +1,19 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 Citrix Systems, Inc.
+# Copyright 2011 OpenStack LLC.
+#
+#    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.
+"""
+:mod:`vmwareapi` -- Nova support for VMware ESX/ESXi Server through VMware API.
+"""
diff --git a/nova/virt/vmwareapi/error_util.py b/nova/virt/vmwareapi/error_util.py
new file mode 100644
index 000000000..53fa8f24d
--- /dev/null
+++ b/nova/virt/vmwareapi/error_util.py
@@ -0,0 +1,96 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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.

+

+"""

+Exception classes and SOAP response error checking module.

+"""

+

+FAULT_NOT_AUTHENTICATED = "NotAuthenticated"

+FAULT_ALREADY_EXISTS = "AlreadyExists"

+

+

+class VimException(Exception):

+    """The VIM Exception class."""

+

+    def __init__(self, exception_summary, excep):

+        Exception.__init__(self)

+        self.exception_summary = exception_summary

+        self.exception_obj = excep

+

+    def __str__(self):

+        return self.exception_summary + str(self.exception_obj)

+

+

+class SessionOverLoadException(VimException):

+    """Session Overload Exception."""

+    pass

+

+

+class VimAttributeError(VimException):

+    """VI Attribute Error."""

+    pass

+

+

+class VimFaultException(Exception):

+    """The VIM Fault exception class."""

+

+    def __init__(self, fault_list, excep):

+        Exception.__init__(self)

+        self.fault_list = fault_list

+        self.exception_obj = excep

+

+    def __str__(self):

+        return str(self.exception_obj)

+

+

+class FaultCheckers(object):

+    """

+    Methods for fault checking of SOAP response. Per Method error handlers

+    for which we desire error checking are defined. SOAP faults are

+    embedded in the SOAP messages as properties and not as SOAP faults.

+    """

+

+    @staticmethod

+    def retrieveproperties_fault_checker(resp_obj):

+        """

+        Checks the RetrieveProperties response for errors. Certain faults

+        are sent as part of the SOAP body as property of missingSet.

+        For example NotAuthenticated fault.

+        """

+        fault_list = []

+        if not resp_obj:

+            # This is the case when the session has timed out. ESX SOAP server

+            # sends an empty RetrievePropertiesResponse. Normally missingSet in

+            # the returnval field has the specifics about the error, but that's

+            # not the case with a timed out idle session. It is as bad as a

+            # terminated session for we cannot use the session. So setting

+            # fault to NotAuthenticated fault.

+            fault_list = ["NotAuthenticated"]

+        else:

+            for obj_cont in resp_obj:

+                if hasattr(obj_cont, "missingSet"):

+                    for missing_elem in obj_cont.missingSet:

+                        fault_type = \

+                            missing_elem.fault.fault.__class__.__name__

+                        # Fault needs to be added to the type of fault for

+                        # uniformity in error checking as SOAP faults define

+                        fault_list.append(fault_type)

+        if fault_list:

+            exc_msg_list = ', '.join(fault_list)

+            raise VimFaultException(fault_list, Exception(_("Error(s) %s "

+                    "occurred in the call to RetrieveProperties") %

+                    exc_msg_list))

diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py
new file mode 100644
index 000000000..4bb467fa9
--- /dev/null
+++ b/nova/virt/vmwareapi/fake.py
@@ -0,0 +1,711 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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 fake VMWare VI API implementation.

+"""

+

+from pprint import pformat

+import uuid

+

+from nova import exception

+from nova import log as logging

+from nova.virt.vmwareapi import vim

+from nova.virt.vmwareapi import error_util

+

+_CLASSES = ['Datacenter', 'Datastore', 'ResourcePool', 'VirtualMachine',

+            'Network', 'HostSystem', 'HostNetworkSystem', 'Task', 'session',

+            'files']

+

+_FAKE_FILE_SIZE = 1024

+

+_db_content = {}

+

+LOG = logging.getLogger("nova.virt.vmwareapi.fake")

+

+

+def log_db_contents(msg=None):

+    """Log DB Contents."""

+    text = msg or ""

+    content = pformat(_db_content)

+    LOG.debug(_("%(text)s: _db_content => %(content)s") % locals())

+

+

+def reset():

+    """Resets the db contents."""

+    for c in _CLASSES:

+        # We fake the datastore by keeping the file references as a list of

+        # names in the db

+        if c == 'files':

+            _db_content[c] = []

+        else:

+            _db_content[c] = {}

+    create_network()

+    create_host_network_system()

+    create_host()

+    create_datacenter()

+    create_datastore()

+    create_res_pool()

+

+

+def cleanup():

+    """Clear the db contents."""

+    for c in _CLASSES:

+        _db_content[c] = {}

+

+

+def _create_object(table, table_obj):

+    """Create an object in the db."""

+    _db_content[table][table_obj.obj] = table_obj

+

+

+def _get_objects(obj_type):

+    """Get objects of the type."""

+    lst_objs = []

+    for key in _db_content[obj_type]:

+        lst_objs.append(_db_content[obj_type][key])

+    return lst_objs

+

+

+class Prop(object):

+    """Property Object base class."""

+

+    def __init__(self):

+        self.name = None

+        self.val = None

+

+

+class ManagedObject(object):

+    """Managed Data Object base class."""

+

+    def __init__(self, name="ManagedObject", obj_ref=None):

+        """Sets the obj property which acts as a reference to the object."""

+        super(ManagedObject, self).__setattr__('objName', name)

+        if obj_ref is None:

+            obj_ref = str(uuid.uuid4())

+        object.__setattr__(self, 'obj', obj_ref)

+        object.__setattr__(self, 'propSet', [])

+

+    def set(self, attr, val):

+        """

+        Sets an attribute value. Not using the __setattr__ directly for we

+        want to set attributes of the type 'a.b.c' and using this function

+        class we set the same.

+        """

+        self.__setattr__(attr, val)

+

+    def get(self, attr):

+        """

+        Gets an attribute. Used as an intermediary to get nested

+        property like 'a.b.c' value.

+        """

+        return self.__getattr__(attr)

+

+    def __setattr__(self, attr, val):

+        for prop in self.propSet:

+            if prop.name == attr:

+                prop.val = val

+                return

+        elem = Prop()

+        elem.name = attr

+        elem.val = val

+        self.propSet.append(elem)

+

+    def __getattr__(self, attr):

+        for elem in self.propSet:

+            if elem.name == attr:

+                return elem.val

+        raise exception.Error(_("Property %(attr)s not set for the managed "

+                        "object %(objName)s") %

+                        {'attr': attr,

+                         'objName': self.objName})

+

+

+class DataObject(object):

+    """Data object base class."""

+    pass

+

+

+class VirtualDisk(DataObject):

+    """

+    Virtual Disk class. Does nothing special except setting

+    __class__.__name__ to 'VirtualDisk'. Refer place where __class__.__name__

+    is used in the code.

+    """

+    pass

+

+

+class VirtualDiskFlatVer2BackingInfo(DataObject):

+    """VirtualDiskFlatVer2BackingInfo class."""

+    pass

+

+

+class VirtualLsiLogicController(DataObject):

+    """VirtualLsiLogicController class."""

+    pass

+

+

+class VirtualMachine(ManagedObject):

+    """Virtual Machine class."""

+

+    def __init__(self, **kwargs):

+        super(VirtualMachine, self).__init__("VirtualMachine")

+        self.set("name", kwargs.get("name"))

+        self.set("runtime.connectionState",

+                 kwargs.get("conn_state", "connected"))

+        self.set("summary.config.guestId", kwargs.get("guest", "otherGuest"))

+        ds_do = DataObject()

+        ds_do.ManagedObjectReference = [kwargs.get("ds").obj]

+        self.set("datastore", ds_do)

+        self.set("summary.guest.toolsStatus", kwargs.get("toolsstatus",

+                                "toolsOk"))

+        self.set("summary.guest.toolsRunningStatus", kwargs.get(

+                                "toolsrunningstate", "guestToolsRunning"))

+        self.set("runtime.powerState", kwargs.get("powerstate", "poweredOn"))

+        self.set("config.files.vmPathName", kwargs.get("vmPathName"))

+        self.set("summary.config.numCpu", kwargs.get("numCpu", 1))

+        self.set("summary.config.memorySizeMB", kwargs.get("mem", 1))

+        self.set("config.hardware.device", kwargs.get("virtual_disk", None))

+        self.set("config.extraConfig", kwargs.get("extra_config", None))

+

+    def reconfig(self, factory, val):

+        """

+        Called to reconfigure the VM. Actually customizes the property

+        setting of the Virtual Machine object.

+        """

+        try:

+            # Case of Reconfig of VM to attach disk

+            controller_key = val.deviceChange[1].device.controllerKey

+            filename = val.deviceChange[1].device.backing.fileName

+

+            disk = VirtualDisk()

+            disk.controllerKey = controller_key

+

+            disk_backing = VirtualDiskFlatVer2BackingInfo()

+            disk_backing.fileName = filename

+            disk_backing.key = -101

+            disk.backing = disk_backing

+

+            controller = VirtualLsiLogicController()

+            controller.key = controller_key

+

+            self.set("config.hardware.device", [disk, controller])

+        except AttributeError:

+            # Case of Reconfig of VM to set extra params

+            self.set("config.extraConfig", val.extraConfig)

+

+

+class Network(ManagedObject):

+    """Network class."""

+

+    def __init__(self):

+        super(Network, self).__init__("Network")

+        self.set("summary.name", "vmnet0")

+

+

+class ResourcePool(ManagedObject):

+    """Resource Pool class."""

+

+    def __init__(self):

+        super(ResourcePool, self).__init__("ResourcePool")

+        self.set("name", "ResPool")

+

+

+class Datastore(ManagedObject):

+    """Datastore class."""

+

+    def __init__(self):

+        super(Datastore, self).__init__("Datastore")

+        self.set("summary.type", "VMFS")

+        self.set("summary.name", "fake-ds")

+

+

+class HostNetworkSystem(ManagedObject):

+    """HostNetworkSystem class."""

+

+    def __init__(self):

+        super(HostNetworkSystem, self).__init__("HostNetworkSystem")

+        self.set("name", "networkSystem")

+

+        pnic_do = DataObject()

+        pnic_do.device = "vmnic0"

+

+        net_info_pnic = DataObject()

+        net_info_pnic.PhysicalNic = [pnic_do]

+

+        self.set("networkInfo.pnic", net_info_pnic)

+

+

+class HostSystem(ManagedObject):

+    """Host System class."""

+

+    def __init__(self):

+        super(HostSystem, self).__init__("HostSystem")

+        self.set("name", "ha-host")

+        if _db_content.get("HostNetworkSystem", None) is None:

+            create_host_network_system()

+        host_net_key = _db_content["HostNetworkSystem"].keys()[0]

+        host_net_sys = _db_content["HostNetworkSystem"][host_net_key].obj

+        self.set("configManager.networkSystem", host_net_sys)

+

+        if _db_content.get("Network", None) is None:

+            create_network()

+        net_ref = _db_content["Network"][_db_content["Network"].keys()[0]].obj

+        network_do = DataObject()

+        network_do.ManagedObjectReference = [net_ref]

+        self.set("network", network_do)

+

+        vswitch_do = DataObject()

+        vswitch_do.pnic = ["vmnic0"]

+        vswitch_do.name = "vSwitch0"

+        vswitch_do.portgroup = ["PortGroup-vmnet0"]

+

+        net_swicth = DataObject()

+        net_swicth.HostVirtualSwitch = [vswitch_do]

+        self.set("config.network.vswitch", net_swicth)

+

+        host_pg_do = DataObject()

+        host_pg_do.key = "PortGroup-vmnet0"

+

+        pg_spec = DataObject()

+        pg_spec.vlanId = 0

+        pg_spec.name = "vmnet0"

+

+        host_pg_do.spec = pg_spec

+

+        host_pg = DataObject()

+        host_pg.HostPortGroup = [host_pg_do]

+        self.set("config.network.portgroup", host_pg)

+

+    def _add_port_group(self, spec):

+        """Adds a port group to the host system object in the db."""

+        pg_name = spec.name

+        vswitch_name = spec.vswitchName

+        vlanid = spec.vlanId

+

+        vswitch_do = DataObject()

+        vswitch_do.pnic = ["vmnic0"]

+        vswitch_do.name = vswitch_name

+        vswitch_do.portgroup = ["PortGroup-%s" % pg_name]

+

+        vswitches = self.get("config.network.vswitch").HostVirtualSwitch

+        vswitches.append(vswitch_do)

+

+        host_pg_do = DataObject()

+        host_pg_do.key = "PortGroup-%s" % pg_name

+

+        pg_spec = DataObject()

+        pg_spec.vlanId = vlanid

+        pg_spec.name = pg_name

+

+        host_pg_do.spec = pg_spec

+        host_pgrps = self.get("config.network.portgroup").HostPortGroup

+        host_pgrps.append(host_pg_do)

+

+

+class Datacenter(ManagedObject):

+    """Datacenter class."""

+

+    def __init__(self):

+        super(Datacenter, self).__init__("Datacenter")

+        self.set("name", "ha-datacenter")

+        self.set("vmFolder", "vm_folder_ref")

+        if _db_content.get("Network", None) is None:

+            create_network()

+        net_ref = _db_content["Network"][_db_content["Network"].keys()[0]].obj

+        network_do = DataObject()

+        network_do.ManagedObjectReference = [net_ref]

+        self.set("network", network_do)

+

+

+class Task(ManagedObject):

+    """Task class."""

+

+    def __init__(self, task_name, state="running"):

+        super(Task, self).__init__("Task")

+        info = DataObject

+        info.name = task_name

+        info.state = state

+        self.set("info", info)

+

+

+def create_host_network_system():

+    host_net_system = HostNetworkSystem()

+    _create_object("HostNetworkSystem", host_net_system)

+

+

+def create_host():

+    host_system = HostSystem()

+    _create_object('HostSystem', host_system)

+

+

+def create_datacenter():

+    data_center = Datacenter()

+    _create_object('Datacenter', data_center)

+

+

+def create_datastore():

+    data_store = Datastore()

+    _create_object('Datastore', data_store)

+

+

+def create_res_pool():

+    res_pool = ResourcePool()

+    _create_object('ResourcePool', res_pool)

+

+

+def create_network():

+    network = Network()

+    _create_object('Network', network)

+

+

+def create_task(task_name, state="running"):

+    task = Task(task_name, state)

+    _create_object("Task", task)

+    return task

+

+

+def _add_file(file_path):

+    """Adds a file reference to the  db."""

+    _db_content["files"].append(file_path)

+

+

+def _remove_file(file_path):

+    """Removes a file reference from the db."""

+    if _db_content.get("files") is None:

+        raise exception.NotFound(_("No files have been added yet"))

+    # Check if the remove is for a single file object or for a folder

+    if file_path.find(".vmdk") != -1:

+        if file_path not in _db_content.get("files"):

+            raise exception.NotFound(_("File- '%s' is not there in the "

+                           "datastore") % file_path)

+        _db_content.get("files").remove(file_path)

+    else:

+        # Removes the files in the folder and the folder too from the db

+        for file in _db_content.get("files"):

+            if file.find(file_path) != -1:

+                lst_files = _db_content.get("files")

+                if lst_files and lst_files.count(file):

+                    lst_files.remove(file)

+

+

+def fake_fetch_image(image, instance, **kwargs):

+    """Fakes fetch image call. Just adds a reference to the db for the file."""

+    ds_name = kwargs.get("datastore_name")

+    file_path = kwargs.get("file_path")

+    ds_file_path = "[" + ds_name + "] " + file_path

+    _add_file(ds_file_path)

+

+

+def fake_upload_image(image, instance, **kwargs):

+    """Fakes the upload of an image."""

+    pass

+

+

+def fake_get_vmdk_size_and_properties(image_id, instance):

+    """Fakes the file size and properties fetch for the image file."""

+    props = {"vmware_ostype": "otherGuest",

+            "vmware_adaptertype": "lsiLogic"}

+    return _FAKE_FILE_SIZE, props

+

+

+def _get_vm_mdo(vm_ref):

+    """Gets the Virtual Machine with the ref from the db."""

+    if _db_content.get("VirtualMachine", None) is None:

+            raise exception.NotFound(_("There is no VM registered"))

+    if vm_ref not in _db_content.get("VirtualMachine"):

+        raise exception.NotFound(_("Virtual Machine with ref %s is not "

+                        "there") % vm_ref)

+    return _db_content.get("VirtualMachine")[vm_ref]

+

+

+class FakeFactory(object):

+    """Fake factory class for the suds client."""

+

+    def create(self, obj_name):

+        """Creates a namespace object."""

+        return DataObject()

+

+

+class FakeVim(object):

+    """Fake VIM Class."""

+

+    def __init__(self, protocol="https", host="localhost", trace=None):

+        """

+        Initializes the suds client object, sets the service content

+        contents and the cookies for the session.

+        """

+        self._session = None

+        self.client = DataObject()

+        self.client.factory = FakeFactory()

+

+        transport = DataObject()

+        transport.cookiejar = "Fake-CookieJar"

+        options = DataObject()

+        options.transport = transport

+

+        self.client.options = options

+

+        service_content = self.client.factory.create('ns0:ServiceContent')

+        service_content.propertyCollector = "PropCollector"

+        service_content.virtualDiskManager = "VirtualDiskManager"

+        service_content.fileManager = "FileManager"

+        service_content.rootFolder = "RootFolder"

+        service_content.sessionManager = "SessionManager"

+        self._service_content = service_content

+

+    def get_service_content(self):

+        return self._service_content

+

+    def __repr__(self):

+        return "Fake VIM Object"

+

+    def __str__(self):

+        return "Fake VIM Object"

+

+    def _login(self):

+        """Logs in and sets the session object in the db."""

+        self._session = str(uuid.uuid4())

+        session = DataObject()

+        session.key = self._session

+        _db_content['session'][self._session] = session

+        return session

+

+    def _logout(self):

+        """Logs out and remove the session object ref from the db."""

+        s = self._session

+        self._session = None

+        if s not in _db_content['session']:

+            raise exception.Error(

+                _("Logging out a session that is invalid or already logged "

+                "out: %s") % s)

+        del _db_content['session'][s]

+

+    def _terminate_session(self, *args, **kwargs):

+        """Terminates a session."""

+        s = kwargs.get("sessionId")[0]

+        if s not in _db_content['session']:

+            return

+        del _db_content['session'][s]

+

+    def _check_session(self):

+        """Checks if the session is active."""

+        if (self._session is None or self._session not in

+                 _db_content['session']):

+            LOG.debug(_("Session is faulty"))

+            raise error_util.VimFaultException(

+                               [error_util.FAULT_NOT_AUTHENTICATED],

+                               _("Session Invalid"))

+

+    def _create_vm(self, method, *args, **kwargs):

+        """Creates and registers a VM object with the Host System."""

+        config_spec = kwargs.get("config")

+        ds = _db_content["Datastore"][_db_content["Datastore"].keys()[0]]

+        vm_dict = {"name": config_spec.name,

+                  "ds": ds,

+                  "powerstate": "poweredOff",

+                  "vmPathName": config_spec.files.vmPathName,

+                  "numCpu": config_spec.numCPUs,

+                  "mem": config_spec.memoryMB}

+        virtual_machine = VirtualMachine(**vm_dict)

+        _create_object("VirtualMachine", virtual_machine)

+        task_mdo = create_task(method, "success")

+        return task_mdo.obj

+

+    def _reconfig_vm(self, method, *args, **kwargs):

+        """Reconfigures a VM and sets the properties supplied."""

+        vm_ref = args[0]

+        vm_mdo = _get_vm_mdo(vm_ref)

+        vm_mdo.reconfig(self.client.factory, kwargs.get("spec"))

+        task_mdo = create_task(method, "success")

+        return task_mdo.obj

+

+    def _create_copy_disk(self, method, vmdk_file_path):

+        """Creates/copies a vmdk file object in the datastore."""

+        # We need to add/create both .vmdk and .-flat.vmdk files

+        flat_vmdk_file_path = \

+            vmdk_file_path.replace(".vmdk", "-flat.vmdk")

+        _add_file(vmdk_file_path)

+        _add_file(flat_vmdk_file_path)

+        task_mdo = create_task(method, "success")

+        return task_mdo.obj

+

+    def _snapshot_vm(self, method):

+        """Snapshots a VM. Here we do nothing for faking sake."""

+        task_mdo = create_task(method, "success")

+        return task_mdo.obj

+

+    def _delete_disk(self, method, *args, **kwargs):

+        """Deletes .vmdk and -flat.vmdk files corresponding to the VM."""

+        vmdk_file_path = kwargs.get("name")

+        flat_vmdk_file_path = \

+            vmdk_file_path.replace(".vmdk", "-flat.vmdk")

+        _remove_file(vmdk_file_path)

+        _remove_file(flat_vmdk_file_path)

+        task_mdo = create_task(method, "success")

+        return task_mdo.obj

+

+    def _delete_file(self, method, *args, **kwargs):

+        """Deletes a file from the datastore."""

+        _remove_file(kwargs.get("name"))

+        task_mdo = create_task(method, "success")

+        return task_mdo.obj

+

+    def _just_return(self):

+        """Fakes a return."""

+        return

+

+    def _unregister_vm(self, method, *args, **kwargs):

+        """Unregisters a VM from the Host System."""

+        vm_ref = args[0]

+        _get_vm_mdo(vm_ref)

+        del _db_content["VirtualMachine"][vm_ref]

+

+    def _search_ds(self, method, *args, **kwargs):

+        """Searches the datastore for a file."""

+        ds_path = kwargs.get("datastorePath")

+        if _db_content.get("files", None) is None:

+            raise exception.NotFound(_("No files have been added yet"))

+        for file in _db_content.get("files"):

+            if file.find(ds_path) != -1:

+                task_mdo = create_task(method, "success")

+                return task_mdo.obj

+        task_mdo = create_task(method, "error")

+        return task_mdo.obj

+

+    def _make_dir(self, method, *args, **kwargs):

+        """Creates a directory in the datastore."""

+        ds_path = kwargs.get("name")

+        if _db_content.get("files", None) is None:

+            raise exception.NotFound(_("No files have been added yet"))

+        _db_content["files"].append(ds_path)

+

+    def _set_power_state(self, method, vm_ref, pwr_state="poweredOn"):

+        """Sets power state for the VM."""

+        if _db_content.get("VirtualMachine", None) is None:

+            raise exception.NotFound(_(" No Virtual Machine has been "

+                                       "registered yet"))

+        if vm_ref not in _db_content.get("VirtualMachine"):

+            raise exception.NotFound(_("Virtual Machine with ref %s is not "

+                                       "there") % vm_ref)

+        vm_mdo = _db_content.get("VirtualMachine").get(vm_ref)

+        vm_mdo.set("runtime.powerState", pwr_state)

+        task_mdo = create_task(method, "success")

+        return task_mdo.obj

+

+    def _retrieve_properties(self, method, *args, **kwargs):

+        """Retrieves properties based on the type."""

+        spec_set = kwargs.get("specSet")[0]

+        type = spec_set.propSet[0].type

+        properties = spec_set.propSet[0].pathSet

+        objs = spec_set.objectSet

+        lst_ret_objs = []

+        for obj in objs:

+            try:

+                obj_ref = obj.obj

+                # This means that we are doing a search for the managed

+                # dataobjects of the type in the inventory

+                if obj_ref == "RootFolder":

+                    for mdo_ref in _db_content[type]:

+                        mdo = _db_content[type][mdo_ref]

+                        # Create a temp Managed object which has the same ref

+                        # as the parent object and copies just the properties

+                        # asked for. We need .obj along with the propSet of

+                        # just the properties asked for

+                        temp_mdo = ManagedObject(mdo.objName, mdo.obj)

+                        for prop in properties:

+                            temp_mdo.set(prop, mdo.get(prop))

+                        lst_ret_objs.append(temp_mdo)

+                else:

+                    if obj_ref in _db_content[type]:

+                        mdo = _db_content[type][obj_ref]

+                        temp_mdo = ManagedObject(mdo.objName, obj_ref)

+                        for prop in properties:

+                            temp_mdo.set(prop, mdo.get(prop))

+                        lst_ret_objs.append(temp_mdo)

+            except Exception, exc:

+                LOG.exception(exc)

+                continue

+        return lst_ret_objs

+

+    def _add_port_group(self, method, *args, **kwargs):

+        """Adds a port group to the host system."""

+        host_mdo = \

+            _db_content["HostSystem"][_db_content["HostSystem"].keys()[0]]

+        host_mdo._add_port_group(kwargs.get("portgrp"))

+

+    def __getattr__(self, attr_name):

+        if attr_name != "Login":

+            self._check_session()

+        if attr_name == "Login":

+            return lambda *args, **kwargs: self._login()

+        elif attr_name == "Logout":

+            self._logout()

+        elif attr_name == "TerminateSession":

+            return lambda *args, **kwargs: self._terminate_session(

+                                               *args, **kwargs)

+        elif attr_name == "CreateVM_Task":

+            return lambda *args, **kwargs: self._create_vm(attr_name,

+                                                *args, **kwargs)

+        elif attr_name == "ReconfigVM_Task":

+            return lambda *args, **kwargs: self._reconfig_vm(attr_name,

+                                                *args, **kwargs)

+        elif attr_name == "CreateVirtualDisk_Task":

+            return lambda *args, **kwargs: self._create_copy_disk(attr_name,

+                                                kwargs.get("name"))

+        elif attr_name == "DeleteDatastoreFile_Task":

+            return lambda *args, **kwargs: self._delete_file(attr_name,

+                                                *args, **kwargs)

+        elif attr_name == "PowerOnVM_Task":

+            return lambda *args, **kwargs: self._set_power_state(attr_name,

+                                                args[0], "poweredOn")

+        elif attr_name == "PowerOffVM_Task":

+            return lambda *args, **kwargs: self._set_power_state(attr_name,

+                                                args[0], "poweredOff")

+        elif attr_name == "RebootGuest":

+            return lambda *args, **kwargs: self._just_return()

+        elif attr_name == "ResetVM_Task":

+            return lambda *args, **kwargs: self._set_power_state(attr_name,

+                                                args[0], "poweredOn")

+        elif attr_name == "SuspendVM_Task":

+            return lambda *args, **kwargs: self._set_power_state(attr_name,

+                                                args[0], "suspended")

+        elif attr_name == "CreateSnapshot_Task":

+            return lambda *args, **kwargs: self._snapshot_vm(attr_name)

+        elif attr_name == "CopyVirtualDisk_Task":

+            return lambda *args, **kwargs: self._create_copy_disk(attr_name,

+                                                kwargs.get("destName"))

+        elif attr_name == "DeleteVirtualDisk_Task":

+            return lambda *args, **kwargs: self._delete_disk(attr_name,

+                                                *args, **kwargs)

+        elif attr_name == "UnregisterVM":

+            return lambda *args, **kwargs: self._unregister_vm(attr_name,

+                                                *args, **kwargs)

+        elif attr_name == "SearchDatastore_Task":

+            return lambda *args, **kwargs: self._search_ds(attr_name,

+                                                *args, **kwargs)

+        elif attr_name == "MakeDirectory":

+            return lambda *args, **kwargs: self._make_dir(attr_name,

+                                                *args, **kwargs)

+        elif attr_name == "RetrieveProperties":

+            return lambda *args, **kwargs: self._retrieve_properties(

+                                                attr_name, *args, **kwargs)

+        elif attr_name == "AcquireCloneTicket":

+            return lambda *args, **kwargs: self._just_return()

+        elif attr_name == "AddPortGroup":

+            return lambda *args, **kwargs: self._add_port_group(attr_name,

+                                                *args, **kwargs)

diff --git a/nova/virt/vmwareapi/io_util.py b/nova/virt/vmwareapi/io_util.py
new file mode 100644
index 000000000..2ec773b7b
--- /dev/null
+++ b/nova/virt/vmwareapi/io_util.py
@@ -0,0 +1,168 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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.

+

+"""

+Utility classes for defining the time saving transfer of data from the reader

+to the write using a LightQueue as a Pipe between the reader and the writer.

+"""

+

+from eventlet import event

+from eventlet import greenthread

+from eventlet.queue import LightQueue

+

+from glance import client

+

+from nova import exception

+from nova import log as logging

+

+LOG = logging.getLogger("nova.virt.vmwareapi.io_util")

+

+IO_THREAD_SLEEP_TIME = .01

+GLANCE_POLL_INTERVAL = 5

+

+

+class ThreadSafePipe(LightQueue):

+    """The pipe to hold the data which the reader writes to and the writer

+    reads from."""

+

+    def __init__(self, maxsize, transfer_size):

+        LightQueue.__init__(self, maxsize)

+        self.transfer_size = transfer_size

+        self.transferred = 0

+

+    def read(self, chunk_size):

+        """Read data from the pipe. Chunksize if ignored for we have ensured

+        that the data chunks written to the pipe by readers is the same as the

+        chunks asked for by the Writer."""

+        if self.transferred < self.transfer_size:

+            data_item = self.get()

+            self.transferred += len(data_item)

+            return data_item

+        else:

+            return ""

+

+    def write(self, data):

+        """Put a data item in the pipe."""

+        self.put(data)

+

+    def close(self):

+        """A place-holder to maintain consistency."""

+        pass

+

+

+class GlanceWriteThread(object):

+    """Ensures that image data is written to in the glance client and that

+    it is in correct ('active')state."""

+

+    def __init__(self, input, glance_client, image_id, image_meta={}):

+        self.input = input

+        self.glance_client = glance_client

+        self.image_id = image_id

+        self.image_meta = image_meta

+        self._running = False

+

+    def start(self):

+        self.done = event.Event()

+

+        def _inner():

+            """Function to do the image data transfer through an update

+            and thereon checks if the state is 'active'."""

+            self.glance_client.update_image(self.image_id,

+                                            image_meta=self.image_meta,

+                                            image_data=self.input)

+            self._running = True

+            while self._running:

+                try:

+                    image_status = \

+                        self.glance_client.get_image_meta(self.image_id).get(

+                                                                "status")

+                    if image_status == "active":

+                        self.stop()

+                        self.done.send(True)

+                    # If the state is killed, then raise an exception.

+                    elif image_status == "killed":

+                        self.stop()

+                        exc_msg = _("Glance image %s is in killed state") %\

+                                    self.image_id

+                        LOG.exception(exc_msg)

+                        self.done.send_exception(exception.Error(exc_msg))

+                    elif image_status in ["saving", "queued"]:

+                        greenthread.sleep(GLANCE_POLL_INTERVAL)

+                    else:

+                        self.stop()

+                        exc_msg = _("Glance image "

+                                    "%(image_id)s is in unknown state "

+                                    "- %(state)s") % {

+                                            "image_id": self.image_id,

+                                            "state": image_status}

+                        LOG.exception(exc_msg)

+                        self.done.send_exception(exception.Error(exc_msg))

+                except Exception, exc:

+                    self.stop()

+                    self.done.send_exception(exc)

+

+        greenthread.spawn(_inner)

+        return self.done

+

+    def stop(self):

+        self._running = False

+

+    def wait(self):

+        return self.done.wait()

+

+    def close(self):

+        pass

+

+

+class IOThread(object):

+    """Class that reads chunks from the input file and writes them to the

+    output file till the transfer is completely done."""

+

+    def __init__(self, input, output):

+        self.input = input

+        self.output = output

+        self._running = False

+        self.got_exception = False

+

+    def start(self):

+        self.done = event.Event()

+

+        def _inner():

+            """Read data from the input and write the same to the output

+            until the transfer completes."""

+            self._running = True

+            while self._running:

+                try:

+                    data = self.input.read(None)

+                    if not data:

+                        self.stop()

+                        self.done.send(True)

+                    self.output.write(data)

+                    greenthread.sleep(IO_THREAD_SLEEP_TIME)

+                except Exception, exc:

+                    self.stop()

+                    LOG.exception(exc)

+                    self.done.send_exception(exc)

+

+        greenthread.spawn(_inner)

+        return self.done

+

+    def stop(self):

+        self._running = False

+

+    def wait(self):

+        return self.done.wait()

diff --git a/nova/virt/vmwareapi/network_utils.py b/nova/virt/vmwareapi/network_utils.py
new file mode 100644
index 000000000..e77842535
--- /dev/null
+++ b/nova/virt/vmwareapi/network_utils.py
@@ -0,0 +1,149 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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.

+

+"""

+Utility functions for ESX Networking.

+"""

+

+from nova import exception

+from nova import log as logging

+from nova.virt.vmwareapi import error_util

+from nova.virt.vmwareapi import vim_util

+from nova.virt.vmwareapi import vm_util

+

+LOG = logging.getLogger("nova.virt.vmwareapi.network_utils")

+

+

+def get_network_with_the_name(session, network_name="vmnet0"):

+    """

+    Gets reference to the network whose name is passed as the

+    argument.

+    """

+    hostsystems = session._call_method(vim_util, "get_objects",

+                "HostSystem", ["network"])

+    vm_networks_ret = hostsystems[0].propSet[0].val

+    # Meaning there are no networks on the host. suds responds with a ""

+    # in the parent property field rather than a [] in the

+    # ManagedObjectRefernce property field of the parent

+    if not vm_networks_ret:

+        return None

+    vm_networks = vm_networks_ret.ManagedObjectReference

+    networks = session._call_method(vim_util,

+                       "get_properties_for_a_collection_of_objects",

+                       "Network", vm_networks, ["summary.name"])

+    for network in networks:

+        if network.propSet[0].val == network_name:

+            return network.obj

+    return None

+

+

+def get_vswitch_for_vlan_interface(session, vlan_interface):

+    """

+    Gets the vswitch associated with the physical network adapter

+    with the name supplied.

+    """

+    # Get the list of vSwicthes on the Host System

+    host_mor = session._call_method(vim_util, "get_objects",

+         "HostSystem")[0].obj

+    vswitches_ret = session._call_method(vim_util,

+                "get_dynamic_property", host_mor,

+                "HostSystem", "config.network.vswitch")

+    # Meaning there are no vSwitches on the host. Shouldn't be the case,

+    # but just doing code check

+    if not vswitches_ret:

+        return

+    vswitches = vswitches_ret.HostVirtualSwitch

+    # Get the vSwitch associated with the network adapter

+    for elem in vswitches:

+        try:

+            for nic_elem in elem.pnic:

+                if str(nic_elem).split('-')[-1].find(vlan_interface) != -1:

+                    return elem.name

+        # Catching Attribute error as a vSwitch may not be associated with a

+        # physical NIC.

+        except AttributeError:

+            pass

+

+

+def check_if_vlan_interface_exists(session, vlan_interface):

+    """Checks if the vlan_inteface exists on the esx host."""

+    host_net_system_mor = session._call_method(vim_util, "get_objects",

+         "HostSystem", ["configManager.networkSystem"])[0].propSet[0].val

+    physical_nics_ret = session._call_method(vim_util,

+                "get_dynamic_property", host_net_system_mor,

+                "HostNetworkSystem", "networkInfo.pnic")

+    # Meaning there are no physical nics on the host

+    if not physical_nics_ret:

+        return False

+    physical_nics = physical_nics_ret.PhysicalNic

+    for pnic in physical_nics:

+        if vlan_interface == pnic.device:

+            return True

+    return False

+

+

+def get_vlanid_and_vswitch_for_portgroup(session, pg_name):

+    """Get the vlan id and vswicth associated with the port group."""

+    host_mor = session._call_method(vim_util, "get_objects",

+         "HostSystem")[0].obj

+    port_grps_on_host_ret = session._call_method(vim_util,

+                "get_dynamic_property", host_mor,

+                "HostSystem", "config.network.portgroup")

+    if not port_grps_on_host_ret:

+        excep = ("ESX SOAP server returned an empty port group "

+                "for the host system in its response")

+        LOG.exception(excep)

+        raise exception.Error(_(excep))

+    port_grps_on_host = port_grps_on_host_ret.HostPortGroup

+    for p_gp in port_grps_on_host:

+        if p_gp.spec.name == pg_name:

+            p_grp_vswitch_name = p_gp.vswitch.split("-")[-1]

+            return p_gp.spec.vlanId, p_grp_vswitch_name

+

+

+def create_port_group(session, pg_name, vswitch_name, vlan_id=0):

+    """

+    Creates a port group on the host system with the vlan tags

+    supplied. VLAN id 0 means no vlan id association.

+    """

+    client_factory = session._get_vim().client.factory

+    add_prt_grp_spec = vm_util.get_add_vswitch_port_group_spec(

+                    client_factory,

+                    vswitch_name,

+                    pg_name,

+                    vlan_id)

+    host_mor = session._call_method(vim_util, "get_objects",

+         "HostSystem")[0].obj

+    network_system_mor = session._call_method(vim_util,

+        "get_dynamic_property", host_mor,

+        "HostSystem", "configManager.networkSystem")

+    LOG.debug(_("Creating Port Group with name %s on "

+                "the ESX host") % pg_name)

+    try:

+        session._call_method(session._get_vim(),

+                "AddPortGroup", network_system_mor,

+                portgrp=add_prt_grp_spec)

+    except error_util.VimFaultException, exc:

+        # There can be a race condition when two instances try

+        # adding port groups at the same time. One succeeds, then

+        # the other one will get an exception. Since we are

+        # concerned with the port group being created, which is done

+        # by the other call, we can ignore the exception.

+        if error_util.FAULT_ALREADY_EXISTS not in exc.fault_list:

+            raise exception.Error(exc)

+    LOG.debug(_("Created Port Group with name %s on "

+                "the ESX host") % pg_name)

diff --git a/nova/virt/vmwareapi/read_write_util.py b/nova/virt/vmwareapi/read_write_util.py
new file mode 100644
index 000000000..84f4942eb
--- /dev/null
+++ b/nova/virt/vmwareapi/read_write_util.py
@@ -0,0 +1,182 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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.

+

+"""Classes to handle image files

+

+Collection of classes to handle image upload/download to/from Image service

+(like Glance image storage and retrieval service) from/to ESX/ESXi server.

+

+"""

+

+import httplib

+import urllib

+import urllib2

+import urlparse

+

+from eventlet import event

+from eventlet import greenthread

+

+from glance import client

+

+from nova import flags

+from nova import log as logging

+

+LOG = logging.getLogger("nova.virt.vmwareapi.read_write_util")

+

+FLAGS = flags.FLAGS

+

+USER_AGENT = "OpenStack-ESX-Adapter"

+

+try:

+    READ_CHUNKSIZE = client.BaseClient.CHUNKSIZE

+except AttributeError:

+    READ_CHUNKSIZE = 65536

+

+

+class GlanceFileRead(object):

+    """Glance file read handler class."""

+

+    def __init__(self, glance_read_iter):

+        self.glance_read_iter = glance_read_iter

+        self.iter = self.get_next()

+

+    def read(self, chunk_size):

+        """Read an item from the queue. The chunk size is ignored for the

+        Client ImageBodyIterator uses its own CHUNKSIZE."""

+        try:

+            return self.iter.next()

+        except StopIteration:

+            return ""

+

+    def get_next(self):

+        """Get the next item from the image iterator."""

+        for data in self.glance_read_iter:

+            yield data

+

+    def close(self):

+        """A dummy close just to maintain consistency."""

+        pass

+

+

+class VMwareHTTPFile(object):

+    """Base class for HTTP file."""

+

+    def __init__(self, file_handle):

+        self.eof = False

+        self.file_handle = file_handle

+

+    def set_eof(self, eof):

+        """Set the end of file marker."""

+        self.eof = eof

+

+    def get_eof(self):

+        """Check if the end of file has been reached."""

+        return self.eof

+

+    def close(self):

+        """Close the file handle."""

+        try:

+            self.file_handle.close()

+        except Exception, exc:

+            LOG.exception(exc)

+

+    def __del__(self):

+        """Close the file handle on garbage collection."""

+        self.close()

+

+    def _build_vim_cookie_headers(self, vim_cookies):

+        """Build ESX host session cookie headers."""

+        cookie_header = ""

+        for vim_cookie in vim_cookies:

+            cookie_header = vim_cookie.name + "=" + vim_cookie.value

+            break

+        return cookie_header

+

+    def write(self, data):

+        """Write data to the file."""

+        raise NotImplementedError

+

+    def read(self, chunk_size):

+        """Read a chunk of data."""

+        raise NotImplementedError

+

+    def get_size(self):

+        """Get size of the file to be read."""

+        raise NotImplementedError

+

+

+class VMWareHTTPWriteFile(VMwareHTTPFile):

+    """VMWare file write handler class."""

+

+    def __init__(self, host, data_center_name, datastore_name, cookies,

+                 file_path, file_size, scheme="https"):

+        base_url = "%s://%s/folder/%s" % (scheme, host, file_path)

+        param_list = {"dcPath": data_center_name, "dsName": datastore_name}

+        base_url = base_url + "?" + urllib.urlencode(param_list)

+        (scheme, netloc, path, params, query, fragment) = \

+            urlparse.urlparse(base_url)

+        if scheme == "http":

+            conn = httplib.HTTPConnection(netloc)

+        elif scheme == "https":

+            conn = httplib.HTTPSConnection(netloc)

+        conn.putrequest("PUT", path + "?" + query)

+        conn.putheader("User-Agent", USER_AGENT)

+        conn.putheader("Content-Length", file_size)

+        conn.putheader("Cookie", self._build_vim_cookie_headers(cookies))

+        conn.endheaders()

+        self.conn = conn

+        VMwareHTTPFile.__init__(self, conn)

+

+    def write(self, data):

+        """Write to the file."""

+        self.file_handle.send(data)

+

+    def close(self):

+        """Get the response and close the connection."""

+        try:

+            self.conn.getresponse()

+        except Exception, excep:

+            LOG.debug(_("Exception during HTTP connection close in "

+                      "VMWareHTTpWrite. Exception is %s") % excep)

+        super(VMWareHTTPWriteFile, self).close()

+

+

+class VmWareHTTPReadFile(VMwareHTTPFile):

+    """VMWare file read handler class."""

+

+    def __init__(self, host, data_center_name, datastore_name, cookies,

+                 file_path, scheme="https"):

+        base_url = "%s://%s/folder/%s" % (scheme, host,

+                                          urllib.pathname2url(file_path))

+        param_list = {"dcPath": data_center_name, "dsName": datastore_name}

+        base_url = base_url + "?" + urllib.urlencode(param_list)

+        headers = {'User-Agent': USER_AGENT,

+                   'Cookie': self._build_vim_cookie_headers(cookies)}

+        request = urllib2.Request(base_url, None, headers)

+        conn = urllib2.urlopen(request)

+        VMwareHTTPFile.__init__(self, conn)

+

+    def read(self, chunk_size):

+        """Read a chunk of data."""

+        # We are ignoring the chunk size passed for we want the pipe to hold

+        # data items of the chunk-size that Glance Client uses for read

+        # while writing.

+        return self.file_handle.read(READ_CHUNKSIZE)

+

+    def get_size(self):

+        """Get size of the file to be read."""

+        return self.file_handle.headers.get("Content-Length", -1)

diff --git a/nova/virt/vmwareapi/vim.py b/nova/virt/vmwareapi/vim.py
new file mode 100644
index 000000000..ba14f1512
--- /dev/null
+++ b/nova/virt/vmwareapi/vim.py
@@ -0,0 +1,176 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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.

+

+"""

+Classes for making VMware VI SOAP calls.

+"""

+

+import httplib

+

+from suds import WebFault

+from suds.client import Client

+from suds.plugin import MessagePlugin

+from suds.sudsobject import Property

+

+from nova import flags

+from nova.virt.vmwareapi import error_util

+

+RESP_NOT_XML_ERROR = 'Response is "text/html", not "text/xml"'

+CONN_ABORT_ERROR = 'Software caused connection abort'

+ADDRESS_IN_USE_ERROR = 'Address already in use'

+

+FLAGS = flags.FLAGS

+flags.DEFINE_string('vmwareapi_wsdl_loc',

+                   None,

+                   'VIM Service WSDL Location'

+                   'e.g http://<server>/vimService.wsdl'

+                   'Due to a bug in vSphere ESX 4.1 default wsdl'

+                   'Refer readme-vmware to setup')

+

+

+class VIMMessagePlugin(MessagePlugin):

+

+    def addAttributeForValue(self, node):

+        # suds does not handle AnyType properly.

+        # VI SDK requires type attribute to be set when AnyType is used

+        if node.name == 'value':

+            node.set('xsi:type', 'xsd:string')

+

+    def marshalled(self, context):

+        """suds will send the specified soap envelope.

+        Provides the plugin with the opportunity to prune empty

+        nodes and fixup nodes before sending it to the server.

+        """

+        # suds builds the entire request object based on the wsdl schema.

+        # VI SDK throws server errors if optional SOAP nodes are sent without

+        # values, e.g. <test/> as opposed to <test>test</test>

+        context.envelope.prune()

+        context.envelope.walk(self.addAttributeForValue)

+

+

+class Vim:

+    """The VIM Object."""

+

+    def __init__(self,

+                 protocol="https",

+                 host="localhost"):

+        """

+        Creates the necessary Communication interfaces and gets the

+        ServiceContent for initiating SOAP transactions.

+

+        protocol: http or https

+        host    : ESX IPAddress[:port] or ESX Hostname[:port]

+        """

+        self._protocol = protocol

+        self._host_name = host

+        wsdl_url = FLAGS.vmwareapi_wsdl_loc

+        if wsdl_url is None:

+            raise Exception(_("Must specify vmwareapi_wsdl_loc"))

+        # TODO(sateesh): Use this when VMware fixes their faulty wsdl

+        #wsdl_url = '%s://%s/sdk/vimService.wsdl' % (self._protocol,

+        #        self._host_name)

+        url = '%s://%s/sdk' % (self._protocol, self._host_name)

+        self.client = Client(wsdl_url, location=url,

+                            plugins=[VIMMessagePlugin()])

+        self._service_content = \

+                self.RetrieveServiceContent("ServiceInstance")

+

+    def get_service_content(self):

+        """Gets the service content object."""

+        return self._service_content

+

+    def __getattr__(self, attr_name):

+        """Makes the API calls and gets the result."""

+        try:

+            return object.__getattr__(self, attr_name)

+        except AttributeError:

+

+            def vim_request_handler(managed_object, **kwargs):

+                """

+                Builds the SOAP message and parses the response for fault

+                checking and other errors.

+

+                managed_object    : Managed Object Reference or Managed

+                                    Object Name

+                **kwargs          : Keyword arguments of the call

+                """

+                # Dynamic handler for VI SDK Calls

+                try:

+                    request_mo = \

+                        self._request_managed_object_builder(managed_object)

+                    request = getattr(self.client.service, attr_name)

+                    response = request(request_mo, **kwargs)

+                    # To check for the faults that are part of the message body

+                    # and not returned as Fault object response from the ESX

+                    # SOAP server

+                    if hasattr(error_util.FaultCheckers,

+                                    attr_name.lower() + "_fault_checker"):

+                        fault_checker = getattr(error_util.FaultCheckers,

+                                    attr_name.lower() + "_fault_checker")

+                        fault_checker(response)

+                    return response

+                # Catch the VimFaultException that is raised by the fault

+                # check of the SOAP response

+                except error_util.VimFaultException, excep:

+                    raise

+                except WebFault, excep:

+                    doc = excep.document

+                    detail = doc.childAtPath("/Envelope/Body/Fault/detail")

+                    fault_list = []

+                    for child in detail.getChildren():

+                        fault_list.append(child.get("type"))

+                    raise error_util.VimFaultException(fault_list, excep)

+                except AttributeError, excep:

+                    raise error_util.VimAttributeError(_("No such SOAP method "

+                         "'%s' provided by VI SDK") % (attr_name), excep)

+                except (httplib.CannotSendRequest,

+                        httplib.ResponseNotReady,

+                        httplib.CannotSendHeader), excep:

+                    raise error_util.SessionOverLoadException(_("httplib "

+                                    "error in %s: ") % (attr_name), excep)

+                except Exception, excep:

+                    # Socket errors which need special handling for they

+                    # might be caused by ESX API call overload

+                    if (str(excep).find(ADDRESS_IN_USE_ERROR) != -1 or

+                        str(excep).find(CONN_ABORT_ERROR)) != -1:

+                        raise error_util.SessionOverLoadException(_("Socket "

+                                    "error in %s: ") % (attr_name), excep)

+                    # Type error that needs special handling for it might be

+                    # caused by ESX host API call overload

+                    elif str(excep).find(RESP_NOT_XML_ERROR) != -1:

+                        raise error_util.SessionOverLoadException(_("Type "

+                                    "error in  %s: ") % (attr_name), excep)

+                    else:

+                        raise error_util.VimException(

+                           _("Exception in %s ") % (attr_name), excep)

+            return vim_request_handler

+

+    def _request_managed_object_builder(self, managed_object):

+        """Builds the request managed object."""

+        # Request Managed Object Builder

+        if type(managed_object) == type(""):

+            mo = Property(managed_object)

+            mo._type = managed_object

+        else:

+            mo = managed_object

+        return mo

+

+    def __repr__(self):

+        return "VIM Object"

+

+    def __str__(self):

+        return "VIM Object"

diff --git a/nova/virt/vmwareapi/vim_util.py b/nova/virt/vmwareapi/vim_util.py
new file mode 100644
index 000000000..11214231c
--- /dev/null
+++ b/nova/virt/vmwareapi/vim_util.py
@@ -0,0 +1,217 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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.

+

+"""

+The VMware API utility module.

+"""

+

+

+def build_selection_spec(client_factory, name):

+    """Builds the selection spec."""

+    sel_spec = client_factory.create('ns0:SelectionSpec')

+    sel_spec.name = name

+    return sel_spec

+

+

+def build_traversal_spec(client_factory, name, spec_type, path, skip,

+                         select_set):

+    """Builds the traversal spec object."""

+    traversal_spec = client_factory.create('ns0:TraversalSpec')

+    traversal_spec.name = name

+    traversal_spec.type = spec_type

+    traversal_spec.path = path

+    traversal_spec.skip = skip

+    traversal_spec.selectSet = select_set

+    return traversal_spec

+

+

+def build_recursive_traversal_spec(client_factory):

+    """

+    Builds the Recursive Traversal Spec to traverse the object managed

+    object hierarchy.

+    """

+    visit_folders_select_spec = build_selection_spec(client_factory,

+                                    "visitFolders")

+    # For getting to hostFolder from datacenter

+    dc_to_hf = build_traversal_spec(client_factory, "dc_to_hf", "Datacenter",

+                                    "hostFolder", False,

+                                    [visit_folders_select_spec])

+    # For getting to vmFolder from datacenter

+    dc_to_vmf = build_traversal_spec(client_factory, "dc_to_vmf", "Datacenter",

+                                     "vmFolder", False,

+                                     [visit_folders_select_spec])

+    # For getting Host System to virtual machine

+    h_to_vm = build_traversal_spec(client_factory, "h_to_vm", "HostSystem",

+                                   "vm", False,

+                                   [visit_folders_select_spec])

+

+    # For getting to Host System from Compute Resource

+    cr_to_h = build_traversal_spec(client_factory, "cr_to_h",

+                                   "ComputeResource", "host", False, [])

+

+    # For getting to datastore from Compute Resource

+    cr_to_ds = build_traversal_spec(client_factory, "cr_to_ds",

+                                    "ComputeResource", "datastore", False, [])

+

+    rp_to_rp_select_spec = build_selection_spec(client_factory, "rp_to_rp")

+    rp_to_vm_select_spec = build_selection_spec(client_factory, "rp_to_vm")

+    # For getting to resource pool from Compute Resource

+    cr_to_rp = build_traversal_spec(client_factory, "cr_to_rp",

+                                "ComputeResource", "resourcePool", False,

+                                [rp_to_rp_select_spec, rp_to_vm_select_spec])

+

+    # For getting to child res pool from the parent res pool

+    rp_to_rp = build_traversal_spec(client_factory, "rp_to_rp", "ResourcePool",

+                                "resourcePool", False,

+                                [rp_to_rp_select_spec, rp_to_vm_select_spec])

+

+    # For getting to Virtual Machine from the Resource Pool

+    rp_to_vm = build_traversal_spec(client_factory, "rp_to_vm", "ResourcePool",

+                                "vm", False,

+                                [rp_to_rp_select_spec, rp_to_vm_select_spec])

+

+    # Get the assorted traversal spec which takes care of the objects to

+    # be searched for from the root folder

+    traversal_spec = build_traversal_spec(client_factory, "visitFolders",

+                                  "Folder", "childEntity", False,

+                                  [visit_folders_select_spec, dc_to_hf,

+                                   dc_to_vmf, cr_to_ds, cr_to_h, cr_to_rp,

+                                   rp_to_rp, h_to_vm, rp_to_vm])

+    return traversal_spec

+

+

+def build_property_spec(client_factory, type="VirtualMachine",

+                        properties_to_collect=["name"],

+                        all_properties=False):

+    """Builds the Property Spec."""

+    property_spec = client_factory.create('ns0:PropertySpec')

+    property_spec.all = all_properties

+    property_spec.pathSet = properties_to_collect

+    property_spec.type = type

+    return property_spec

+

+

+def build_object_spec(client_factory, root_folder, traversal_specs):

+    """Builds the object Spec."""

+    object_spec = client_factory.create('ns0:ObjectSpec')

+    object_spec.obj = root_folder

+    object_spec.skip = False

+    object_spec.selectSet = traversal_specs

+    return object_spec

+

+

+def build_property_filter_spec(client_factory, property_specs, object_specs):

+    """Builds the Property Filter Spec."""

+    property_filter_spec = client_factory.create('ns0:PropertyFilterSpec')

+    property_filter_spec.propSet = property_specs

+    property_filter_spec.objectSet = object_specs

+    return property_filter_spec

+

+

+def get_object_properties(vim, collector, mobj, type, properties):

+    """Gets the properties of the Managed object specified."""

+    client_factory = vim.client.factory

+    if mobj is None:

+        return None

+    usecoll = collector

+    if usecoll is None:

+        usecoll = vim.get_service_content().propertyCollector

+    property_filter_spec = client_factory.create('ns0:PropertyFilterSpec')

+    property_spec = client_factory.create('ns0:PropertySpec')

+    property_spec.all = (properties is None or len(properties) == 0)

+    property_spec.pathSet = properties

+    property_spec.type = type

+    object_spec = client_factory.create('ns0:ObjectSpec')

+    object_spec.obj = mobj

+    object_spec.skip = False

+    property_filter_spec.propSet = [property_spec]

+    property_filter_spec.objectSet = [object_spec]

+    return vim.RetrieveProperties(usecoll, specSet=[property_filter_spec])

+

+

+def get_dynamic_property(vim, mobj, type, property_name):

+    """Gets a particular property of the Managed Object."""

+    obj_content = \

+        get_object_properties(vim, None, mobj, type, [property_name])

+    property_value = None

+    if obj_content:

+        dynamic_property = obj_content[0].propSet

+        if dynamic_property:

+            property_value = dynamic_property[0].val

+    return property_value

+

+

+def get_objects(vim, type, properties_to_collect=["name"], all=False):

+    """Gets the list of objects of the type specified."""

+    client_factory = vim.client.factory

+    object_spec = build_object_spec(client_factory,

+                        vim.get_service_content().rootFolder,

+                        [build_recursive_traversal_spec(client_factory)])

+    property_spec = build_property_spec(client_factory, type=type,

+                                properties_to_collect=properties_to_collect,

+                                all_properties=all)

+    property_filter_spec = build_property_filter_spec(client_factory,

+                                [property_spec],

+                                [object_spec])

+    return vim.RetrieveProperties(vim.get_service_content().propertyCollector,

+                                specSet=[property_filter_spec])

+

+

+def get_prop_spec(client_factory, spec_type, properties):

+    """Builds the Property Spec Object."""

+    prop_spec = client_factory.create('ns0:PropertySpec')

+    prop_spec.type = spec_type

+    prop_spec.pathSet = properties

+    return prop_spec

+

+

+def get_obj_spec(client_factory, obj, select_set=None):

+    """Builds the Object Spec object."""

+    obj_spec = client_factory.create('ns0:ObjectSpec')

+    obj_spec.obj = obj

+    obj_spec.skip = False

+    if select_set is not None:

+        obj_spec.selectSet = select_set

+    return obj_spec

+

+

+def get_prop_filter_spec(client_factory, obj_spec, prop_spec):

+    """Builds the Property Filter Spec Object."""

+    prop_filter_spec = \

+        client_factory.create('ns0:PropertyFilterSpec')

+    prop_filter_spec.propSet = prop_spec

+    prop_filter_spec.objectSet = obj_spec

+    return prop_filter_spec

+

+

+def get_properties_for_a_collection_of_objects(vim, type,

+                                               obj_list, properties):

+    """

+    Gets the list of properties for the collection of

+    objects of the type specified.

+    """

+    client_factory = vim.client.factory

+    if len(obj_list) == 0:

+        return []

+    prop_spec = get_prop_spec(client_factory, type, properties)

+    lst_obj_specs = []

+    for obj in obj_list:

+        lst_obj_specs.append(get_obj_spec(client_factory, obj))

+    prop_filter_spec = get_prop_filter_spec(client_factory,

+                                            lst_obj_specs, [prop_spec])

+    return vim.RetrieveProperties(vim.get_service_content().propertyCollector,

+                                   specSet=[prop_filter_spec])

diff --git a/nova/virt/vmwareapi/vm_util.py b/nova/virt/vmwareapi/vm_util.py
new file mode 100644
index 000000000..a2fa7600c
--- /dev/null
+++ b/nova/virt/vmwareapi/vm_util.py
@@ -0,0 +1,306 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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.

+"""

+The VMware API VM utility module to build SOAP object specs.

+"""

+

+

+def build_datastore_path(datastore_name, path):

+    """Build the datastore compliant path."""

+    return "[%s] %s" % (datastore_name, path)

+

+

+def split_datastore_path(datastore_path):

+    """

+    Split the VMWare style datastore path to get the Datastore

+    name and the entity path.

+    """

+    spl = datastore_path.split('[', 1)[1].split(']', 1)

+    path = ""

+    if len(spl) == 1:

+        datastore_url = spl[0]

+    else:

+        datastore_url, path = spl

+    return datastore_url, path.strip()

+

+

+def get_vm_create_spec(client_factory, instance, data_store_name,

+                       network_name="vmnet0",

+                       os_type="otherGuest"):

+    """Builds the VM Create spec."""

+    config_spec = client_factory.create('ns0:VirtualMachineConfigSpec')

+    config_spec.name = instance.name

+    config_spec.guestId = os_type

+

+    vm_file_info = client_factory.create('ns0:VirtualMachineFileInfo')

+    vm_file_info.vmPathName = "[" + data_store_name + "]"

+    config_spec.files = vm_file_info

+

+    tools_info = client_factory.create('ns0:ToolsConfigInfo')

+    tools_info.afterPowerOn = True

+    tools_info.afterResume = True

+    tools_info.beforeGuestStandby = True

+    tools_info.beforeGuestShutdown = True

+    tools_info.beforeGuestReboot = True

+

+    config_spec.tools = tools_info

+    config_spec.numCPUs = int(instance.vcpus)

+    config_spec.memoryMB = int(instance.memory_mb)

+

+    nic_spec = create_network_spec(client_factory,

+                                    network_name, instance.mac_address)

+

+    device_config_spec = [nic_spec]

+

+    config_spec.deviceChange = device_config_spec

+    return config_spec

+

+

+def create_controller_spec(client_factory, key):

+    """

+    Builds a Config Spec for the LSI Logic Controller's addition

+    which acts as the controller for the virtual hard disk to be attached

+    to the VM.

+    """

+    # Create a controller for the Virtual Hard Disk

+    virtual_device_config = \

+        client_factory.create('ns0:VirtualDeviceConfigSpec')

+    virtual_device_config.operation = "add"

+    virtual_lsi = \

+        client_factory.create('ns0:VirtualLsiLogicController')

+    virtual_lsi.key = key

+    virtual_lsi.busNumber = 0

+    virtual_lsi.sharedBus = "noSharing"

+    virtual_device_config.device = virtual_lsi

+    return virtual_device_config

+

+

+def create_network_spec(client_factory, network_name, mac_address):

+    """

+    Builds a config spec for the addition of a new network

+    adapter to the VM.

+    """

+    network_spec = \

+         client_factory.create('ns0:VirtualDeviceConfigSpec')

+    network_spec.operation = "add"

+

+    # Get the recommended card type for the VM based on the guest OS of the VM

+    net_device = client_factory.create('ns0:VirtualPCNet32')

+

+    backing = \

+        client_factory.create('ns0:VirtualEthernetCardNetworkBackingInfo')

+    backing.deviceName = network_name

+

+    connectable_spec = \

+        client_factory.create('ns0:VirtualDeviceConnectInfo')

+    connectable_spec.startConnected = True

+    connectable_spec.allowGuestControl = True

+    connectable_spec.connected = True

+

+    net_device.connectable = connectable_spec

+    net_device.backing = backing

+

+    # The Server assigns a Key to the device. Here we pass a -ve temporary key.

+    # -ve because actual keys are +ve numbers and we don't

+    # want a clash with the key that server might associate with the device

+    net_device.key = -47

+    net_device.addressType = "manual"

+    net_device.macAddress = mac_address

+    net_device.wakeOnLanEnabled = True

+

+    network_spec.device = net_device

+    return network_spec

+

+

+def get_vmdk_attach_config_spec(client_factory, disksize, file_path,

+                                adapter_type="lsiLogic"):

+    """Builds the vmdk attach config spec."""

+    config_spec = client_factory.create('ns0:VirtualMachineConfigSpec')

+

+    # The controller Key pertains to the Key of the LSI Logic Controller, which

+    # controls this Hard Disk

+    device_config_spec = []

+    # For IDE devices, there are these two default controllers created in the

+    # VM having keys 200 and 201

+    if adapter_type == "ide":

+        controller_key = 200

+    else:

+        controller_key = -101

+        controller_spec = create_controller_spec(client_factory,

+                                            controller_key)

+        device_config_spec.append(controller_spec)

+    virtual_device_config_spec = create_virtual_disk_spec(client_factory,

+                                disksize, controller_key, file_path)

+

+    device_config_spec.append(virtual_device_config_spec)

+

+    config_spec.deviceChange = device_config_spec

+    return config_spec

+

+

+def get_vmdk_file_path_and_adapter_type(client_factory, hardware_devices):

+    """Gets the vmdk file path and the storage adapter type."""

+    if hardware_devices.__class__.__name__ == "ArrayOfVirtualDevice":

+        hardware_devices = hardware_devices.VirtualDevice

+    vmdk_file_path = None

+    vmdk_controler_key = None

+

+    adapter_type_dict = {}

+    for device in hardware_devices:

+        if device.__class__.__name__ == "VirtualDisk" and \

+            device.backing.__class__.__name__ \

+                == "VirtualDiskFlatVer2BackingInfo":

+            vmdk_file_path = device.backing.fileName

+            vmdk_controler_key = device.controllerKey

+        elif device.__class__.__name__ == "VirtualLsiLogicController":

+            adapter_type_dict[device.key] = "lsiLogic"

+        elif device.__class__.__name__ == "VirtualBusLogicController":

+            adapter_type_dict[device.key] = "busLogic"

+        elif device.__class__.__name__ == "VirtualIDEController":

+            adapter_type_dict[device.key] = "ide"

+        elif device.__class__.__name__ == "VirtualLsiLogicSASController":

+            adapter_type_dict[device.key] = "lsiLogic"

+

+    adapter_type = adapter_type_dict.get(vmdk_controler_key, "")

+

+    return vmdk_file_path, adapter_type

+

+

+def get_copy_virtual_disk_spec(client_factory, adapter_type="lsilogic"):

+    """Builds the Virtual Disk copy spec."""

+    dest_spec = client_factory.create('ns0:VirtualDiskSpec')

+    dest_spec.adapterType = adapter_type

+    dest_spec.diskType = "thick"

+    return dest_spec

+

+

+def get_vmdk_create_spec(client_factory, size_in_kb, adapter_type="lsiLogic"):

+    """Builds the virtual disk create spec."""

+    create_vmdk_spec = \

+        client_factory.create('ns0:FileBackedVirtualDiskSpec')

+    create_vmdk_spec.adapterType = adapter_type

+    create_vmdk_spec.diskType = "thick"

+    create_vmdk_spec.capacityKb = size_in_kb

+    return create_vmdk_spec

+

+

+def create_virtual_disk_spec(client_factory, disksize, controller_key,

+                             file_path=None):

+    """

+    Builds spec for the creation of a new/ attaching of an already existing

+    Virtual Disk to the VM.

+    """

+    virtual_device_config = \

+        client_factory.create('ns0:VirtualDeviceConfigSpec')

+    virtual_device_config.operation = "add"

+    if file_path is None:

+        virtual_device_config.fileOperation = "create"

+

+    virtual_disk = client_factory.create('ns0:VirtualDisk')

+

+    disk_file_backing = \

+        client_factory.create('ns0:VirtualDiskFlatVer2BackingInfo')

+    disk_file_backing.diskMode = "persistent"

+    disk_file_backing.thinProvisioned = False

+    if file_path is not None:

+        disk_file_backing.fileName = file_path

+    else:

+        disk_file_backing.fileName = ""

+

+    connectable_spec = client_factory.create('ns0:VirtualDeviceConnectInfo')

+    connectable_spec.startConnected = True

+    connectable_spec.allowGuestControl = False

+    connectable_spec.connected = True

+

+    virtual_disk.backing = disk_file_backing

+    virtual_disk.connectable = connectable_spec

+

+    # The Server assigns a Key to the device. Here we pass a -ve random key.

+    # -ve because actual keys are +ve numbers and we don't

+    # want a clash with the key that server might associate with the device

+    virtual_disk.key = -100

+    virtual_disk.controllerKey = controller_key

+    virtual_disk.unitNumber = 0

+    virtual_disk.capacityInKB = disksize

+

+    virtual_device_config.device = virtual_disk

+

+    return virtual_device_config

+

+

+def get_dummy_vm_create_spec(client_factory, name, data_store_name):

+    """Builds the dummy VM create spec."""

+    config_spec = client_factory.create('ns0:VirtualMachineConfigSpec')

+

+    config_spec.name = name

+    config_spec.guestId = "otherGuest"

+

+    vm_file_info = client_factory.create('ns0:VirtualMachineFileInfo')

+    vm_file_info.vmPathName = "[" + data_store_name + "]"

+    config_spec.files = vm_file_info

+

+    tools_info = client_factory.create('ns0:ToolsConfigInfo')

+    tools_info.afterPowerOn = True

+    tools_info.afterResume = True

+    tools_info.beforeGuestStandby = True

+    tools_info.beforeGuestShutdown = True

+    tools_info.beforeGuestReboot = True

+

+    config_spec.tools = tools_info

+    config_spec.numCPUs = 1

+    config_spec.memoryMB = 4

+

+    controller_key = -101

+    controller_spec = create_controller_spec(client_factory, controller_key)

+    disk_spec = create_virtual_disk_spec(client_factory, 1024, controller_key)

+

+    device_config_spec = [controller_spec, disk_spec]

+

+    config_spec.deviceChange = device_config_spec

+    return config_spec

+

+

+def get_machine_id_change_spec(client_factory, mac, ip_addr, netmask, gateway):

+    """Builds the machine id change config spec."""

+    machine_id_str = "%s;%s;%s;%s" % (mac, ip_addr, netmask, gateway)

+    virtual_machine_config_spec = \

+        client_factory.create('ns0:VirtualMachineConfigSpec')

+

+    opt = client_factory.create('ns0:OptionValue')

+    opt.key = "machine.id"

+    opt.value = machine_id_str

+    virtual_machine_config_spec.extraConfig = [opt]

+    return virtual_machine_config_spec

+

+

+def get_add_vswitch_port_group_spec(client_factory, vswitch_name,

+                                    port_group_name, vlan_id):

+    """Builds the virtual switch port group add spec."""

+    vswitch_port_group_spec = client_factory.create('ns0:HostPortGroupSpec')

+    vswitch_port_group_spec.name = port_group_name

+    vswitch_port_group_spec.vswitchName = vswitch_name

+

+    # VLAN ID of 0 means that VLAN tagging is not to be done for the network.

+    vswitch_port_group_spec.vlanId = int(vlan_id)

+

+    policy = client_factory.create('ns0:HostNetworkPolicy')

+    nicteaming = client_factory.create('ns0:HostNicTeamingPolicy')

+    nicteaming.notifySwitches = True

+    policy.nicTeaming = nicteaming

+

+    vswitch_port_group_spec.policy = policy

+    return vswitch_port_group_spec

diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py
new file mode 100644
index 000000000..cf6c88bbd
--- /dev/null
+++ b/nova/virt/vmwareapi/vmops.py
@@ -0,0 +1,789 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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.

+

+"""

+Class for VM tasks like spawn, snapshot, suspend, resume etc.

+"""

+

+import base64

+import os

+import time

+import urllib

+import urllib2

+import uuid

+

+from nova import context

+from nova import db

+from nova import exception

+from nova import flags

+from nova import log as logging

+from nova.compute import power_state

+from nova.virt.vmwareapi import vim_util

+from nova.virt.vmwareapi import vm_util

+from nova.virt.vmwareapi import vmware_images

+from nova.virt.vmwareapi import network_utils

+

+FLAGS = flags.FLAGS

+LOG = logging.getLogger("nova.virt.vmwareapi.vmops")

+

+VMWARE_POWER_STATES = {

+                   'poweredOff': power_state.SHUTDOWN,

+                    'poweredOn': power_state.RUNNING,

+                    'suspended': power_state.PAUSED}

+

+

+class VMWareVMOps(object):

+    """Management class for VM-related tasks."""

+

+    def __init__(self, session):

+        """Initializer."""

+        self._session = session

+

+    def _wait_with_callback(self, instance_id, task, callback):

+        """Waits for the task to finish and does a callback after."""

+        ret = None

+        try:

+            ret = self._session._wait_for_task(instance_id, task)

+        except Exception, excep:

+            LOG.exception(excep)

+        callback(ret)

+

+    def list_instances(self):

+        """Lists the VM instances that are registered with the ESX host."""

+        LOG.debug(_("Getting list of instances"))

+        vms = self._session._call_method(vim_util, "get_objects",

+                     "VirtualMachine",

+                     ["name", "runtime.connectionState"])

+        lst_vm_names = []

+        for vm in vms:

+            vm_name = None

+            conn_state = None

+            for prop in vm.propSet:

+                if prop.name == "name":

+                    vm_name = prop.val

+                elif prop.name == "runtime.connectionState":

+                    conn_state = prop.val

+            # Ignoring the oprhaned or inaccessible VMs

+            if conn_state not in ["orphaned", "inaccessible"]:

+                lst_vm_names.append(vm_name)

+        LOG.debug(_("Got total of %s instances") % str(len(lst_vm_names)))

+        return lst_vm_names

+

+    def spawn(self, instance):

+        """

+        Creates a VM instance.

+

+        Steps followed are:

+        1. Create a VM with no disk and the specifics in the instance object

+            like RAM size.

+        2. Create a dummy vmdk of the size of the disk file that is to be

+            uploaded. This is required just to create the metadata file.

+        3. Delete the -flat.vmdk file created in the above step and retain

+            the metadata .vmdk file.

+        4. Upload the disk file.

+        5. Attach the disk to the VM by reconfiguring the same.

+        6. Power on the VM.

+        """

+        vm_ref = self._get_vm_ref_from_the_name(instance.name)

+        if vm_ref:

+            raise exception.Duplicate(_("Attempted to create a VM with a name"

+                " %s, but that already exists on the host") % instance.name)

+

+        client_factory = self._session._get_vim().client.factory

+        service_content = self._session._get_vim().get_service_content()

+

+        network = db.network_get_by_instance(context.get_admin_context(),

+                                            instance['id'])

+

+        net_name = network['bridge']

+

+        def _check_if_network_bridge_exists():

+            network_ref = \

+                network_utils.get_network_with_the_name(self._session,

+                                                        net_name)

+            if network_ref is None:

+                raise exception.NotFound(_("Network with the name '%s' doesn't"

+                        " exist on the ESX host") % net_name)

+

+        _check_if_network_bridge_exists()

+

+        def _get_datastore_ref():

+            """Get the datastore list and choose the first local storage."""

+            data_stores = self._session._call_method(vim_util, "get_objects",

+                        "Datastore", ["summary.type", "summary.name"])

+            for elem in data_stores:

+                ds_name = None

+                ds_type = None

+                for prop in elem.propSet:

+                    if prop.name == "summary.type":

+                        ds_type = prop.val

+                    elif prop.name == "summary.name":

+                        ds_name = prop.val

+                # Local storage identifier

+                if ds_type == "VMFS":

+                    data_store_name = ds_name

+                    return data_store_name

+

+            if data_store_name is None:

+                msg = _("Couldn't get a local Datastore reference")

+                LOG.exception(msg)

+                raise exception.Error(msg)

+

+        data_store_name = _get_datastore_ref()

+

+        def _get_image_properties():

+            """

+            Get the Size of the flat vmdk file that is there on the storage

+            repository.

+            """

+            image_size, image_properties = \

+                    vmware_images.get_vmdk_size_and_properties(

+                                       instance.image_id, instance)

+            vmdk_file_size_in_kb = int(image_size) / 1024

+            os_type = image_properties.get("vmware_ostype", "otherGuest")

+            adapter_type = image_properties.get("vmware_adaptertype",

+                                                "lsiLogic")

+            return vmdk_file_size_in_kb, os_type, adapter_type

+

+        vmdk_file_size_in_kb, os_type, adapter_type = _get_image_properties()

+

+        def _get_vmfolder_and_res_pool_mors():

+            """Get the Vm folder ref from the datacenter."""

+            dc_objs = self._session._call_method(vim_util, "get_objects",

+                                    "Datacenter", ["vmFolder"])

+            # There is only one default datacenter in a standalone ESX host

+            vm_folder_mor = dc_objs[0].propSet[0].val

+

+            # Get the resource pool. Taking the first resource pool coming our

+            # way. Assuming that is the default resource pool.

+            res_pool_mor = self._session._call_method(vim_util, "get_objects",

+                                    "ResourcePool")[0].obj

+            return vm_folder_mor, res_pool_mor

+

+        vm_folder_mor, res_pool_mor = _get_vmfolder_and_res_pool_mors()

+

+        # Get the create vm config spec

+        config_spec = vm_util.get_vm_create_spec(client_factory, instance,

+                                data_store_name, net_name, os_type)

+

+        def _execute_create_vm():

+            """Create VM on ESX host."""

+            LOG.debug(_("Creating VM with the name %s on the ESX  host") %

+                      instance.name)

+            # Create the VM on the ESX host

+            vm_create_task = self._session._call_method(

+                                    self._session._get_vim(),

+                                    "CreateVM_Task", vm_folder_mor,

+                                    config=config_spec, pool=res_pool_mor)

+            self._session._wait_for_task(instance.id, vm_create_task)

+

+            LOG.debug(_("Created VM with the name %s on the ESX  host") %

+                      instance.name)

+

+        _execute_create_vm()

+

+        # Set the machine id for the VM for setting the IP

+        self._set_machine_id(client_factory, instance)

+

+        # Naming the VM files in correspondence with the VM instance name

+        # The flat vmdk file name

+        flat_uploaded_vmdk_name = "%s/%s-flat.vmdk" % (instance.name,

+                                                       instance.name)

+        # The vmdk meta-data file

+        uploaded_vmdk_name = "%s/%s.vmdk" % (instance.name, instance.name)

+        flat_uploaded_vmdk_path = vm_util.build_datastore_path(data_store_name,

+                                            flat_uploaded_vmdk_name)

+        uploaded_vmdk_path = vm_util.build_datastore_path(data_store_name,

+                                            uploaded_vmdk_name)

+

+        def _create_virtual_disk():

+            """Create a virtual disk of the size of flat vmdk file."""

+            # Create a Virtual Disk of the size of the flat vmdk file. This is

+            # done just to generate the meta-data file whose specifics

+            # depend on the size of the disk, thin/thick provisioning and the

+            # storage adapter type.

+            # Here we assume thick provisioning and lsiLogic for the adapter

+            # type

+            LOG.debug(_("Creating Virtual Disk of size  "

+                      "%(vmdk_file_size_in_kb)s KB and adapter type  "

+                      "%(adapter_type)s on the ESX host local store"

+                      " %(data_store_name)s") %

+                       {"vmdk_file_size_in_kb": vmdk_file_size_in_kb,

+                        "adapter_type": adapter_type,

+                        "data_store_name": data_store_name})

+            vmdk_create_spec = vm_util.get_vmdk_create_spec(client_factory,

+                                    vmdk_file_size_in_kb, adapter_type)

+            vmdk_create_task = self._session._call_method(

+                self._session._get_vim(),

+                "CreateVirtualDisk_Task",

+                service_content.virtualDiskManager,

+                name=uploaded_vmdk_path,

+                datacenter=self._get_datacenter_name_and_ref()[0],

+                spec=vmdk_create_spec)

+            self._session._wait_for_task(instance.id, vmdk_create_task)

+            LOG.debug(_("Created Virtual Disk of size %(vmdk_file_size_in_kb)s"

+                        " KB on the ESX host local store "

+                        "%(data_store_name)s") %

+                        {"vmdk_file_size_in_kb": vmdk_file_size_in_kb,

+                         "data_store_name": data_store_name})

+

+        _create_virtual_disk()

+

+        def _delete_disk_file():

+            LOG.debug(_("Deleting the file %(flat_uploaded_vmdk_path)s "

+                        "on the ESX host local"

+                        "store %(data_store_name)s") %

+                        {"flat_uploaded_vmdk_path": flat_uploaded_vmdk_path,

+                         "data_store_name": data_store_name})

+            # Delete the -flat.vmdk file created. .vmdk file is retained.

+            vmdk_delete_task = self._session._call_method(

+                        self._session._get_vim(),

+                        "DeleteDatastoreFile_Task",

+                        service_content.fileManager,

+                        name=flat_uploaded_vmdk_path)

+            self._session._wait_for_task(instance.id, vmdk_delete_task)

+            LOG.debug(_("Deleted the file %(flat_uploaded_vmdk_path)s on the "

+                        "ESX host local store %(data_store_name)s") %

+                        {"flat_uploaded_vmdk_path": flat_uploaded_vmdk_path,

+                         "data_store_name": data_store_name})

+

+        _delete_disk_file()

+

+        cookies = self._session._get_vim().client.options.transport.cookiejar

+

+        def _fetch_image_on_esx_datastore():

+            """Fetch image from Glance to ESX datastore."""

+            LOG.debug(_("Downloading image file data %(image_id)s to the ESX "

+                        "data store %(data_store_name)s") %

+                        ({'image_id': instance.image_id,

+                          'data_store_name': data_store_name}))

+            # Upload the -flat.vmdk file whose meta-data file we just created

+            # above

+            vmware_images.fetch_image(

+                instance.image_id,

+                instance,

+                host=self._session._host_ip,

+                data_center_name=self._get_datacenter_name_and_ref()[1],

+                datastore_name=data_store_name,

+                cookies=cookies,

+                file_path=flat_uploaded_vmdk_name)

+            LOG.debug(_("Downloaded image file data %(image_id)s to the ESX "

+                        "data store %(data_store_name)s") %

+                        ({'image_id': instance.image_id,

+                         'data_store_name': data_store_name}))

+        _fetch_image_on_esx_datastore()

+

+        vm_ref = self._get_vm_ref_from_the_name(instance.name)

+

+        def _attach_vmdk_to_the_vm():

+            """

+            Attach the vmdk uploaded to the VM. VM reconfigure is done

+            to do so.

+            """

+            vmdk_attach_config_spec = vm_util.get_vmdk_attach_config_spec(

+                                client_factory,

+                                vmdk_file_size_in_kb, uploaded_vmdk_path,

+                                adapter_type)

+            LOG.debug(_("Reconfiguring VM instance %s to attach the image "

+                      "disk") % instance.name)

+            reconfig_task = self._session._call_method(

+                               self._session._get_vim(),

+                               "ReconfigVM_Task", vm_ref,

+                               spec=vmdk_attach_config_spec)

+            self._session._wait_for_task(instance.id, reconfig_task)

+            LOG.debug(_("Reconfigured VM instance %s to attach the image "

+                      "disk") % instance.name)

+

+        _attach_vmdk_to_the_vm()

+

+        def _power_on_vm():

+            """Power on the VM."""

+            LOG.debug(_("Powering on the VM instance %s") % instance.name)

+            # Power On the VM

+            power_on_task = self._session._call_method(

+                               self._session._get_vim(),

+                               "PowerOnVM_Task", vm_ref)

+            self._session._wait_for_task(instance.id, power_on_task)

+            LOG.debug(_("Powered on the VM instance %s") % instance.name)

+        _power_on_vm()

+

+    def snapshot(self, instance, snapshot_name):

+        """

+        Create snapshot from a running VM instance.

+        Steps followed are:

+        1. Get the name of the vmdk file which the VM points to right now.

+            Can be a chain of snapshots, so we need to know the last in the

+            chain.

+        2. Create the snapshot. A new vmdk is created which the VM points to

+            now. The earlier vmdk becomes read-only.

+        3. Call CopyVirtualDisk which coalesces the disk chain to form a single

+            vmdk, rather a .vmdk metadata file and a -flat.vmdk disk data file.

+        4. Now upload the -flat.vmdk file to the image store.

+        5. Delete the coalesced .vmdk and -flat.vmdk created.

+        """

+        vm_ref = self._get_vm_ref_from_the_name(instance.name)

+        if vm_ref is None:

+            raise exception.NotFound(_("instance - %s not present") %

+                                     instance.name)

+

+        client_factory = self._session._get_vim().client.factory

+        service_content = self._session._get_vim().get_service_content()

+

+        def _get_vm_and_vmdk_attribs():

+            # Get the vmdk file name that the VM is pointing to

+            hardware_devices = self._session._call_method(vim_util,

+                        "get_dynamic_property", vm_ref,

+                        "VirtualMachine", "config.hardware.device")

+            vmdk_file_path_before_snapshot, adapter_type = \

+                vm_util.get_vmdk_file_path_and_adapter_type(client_factory,

+                                                            hardware_devices)

+            datastore_name = vm_util.split_datastore_path(

+                                      vmdk_file_path_before_snapshot)[0]

+            os_type = self._session._call_method(vim_util,

+                        "get_dynamic_property", vm_ref,

+                        "VirtualMachine", "summary.config.guestId")

+            return (vmdk_file_path_before_snapshot, adapter_type,

+                    datastore_name, os_type)

+

+        vmdk_file_path_before_snapshot, adapter_type, datastore_name,\

+            os_type = _get_vm_and_vmdk_attribs()

+

+        def _create_vm_snapshot():

+            # Create a snapshot of the VM

+            LOG.debug(_("Creating Snapshot of the VM instance %s ") %

+                        instance.name)

+            snapshot_task = self._session._call_method(

+                        self._session._get_vim(),

+                        "CreateSnapshot_Task", vm_ref,

+                        name="%s-snapshot" % instance.name,

+                        description="Taking Snapshot of the VM",

+                        memory=True,

+                        quiesce=True)

+            self._session._wait_for_task(instance.id, snapshot_task)

+            LOG.debug(_("Created Snapshot of the VM instance %s ") %

+                      instance.name)

+

+        _create_vm_snapshot()

+

+        def _check_if_tmp_folder_exists():

+            # Copy the contents of the VM that were there just before the

+            # snapshot was taken

+            ds_ref_ret = vim_util.get_dynamic_property(

+                                    self._session._get_vim(),

+                                    vm_ref,

+                                    "VirtualMachine",

+                                    "datastore")

+            if not ds_ref_ret:

+                raise exception.NotFound(_("Failed to get the datastore "

+                                "reference(s) which the VM uses"))

+            ds_ref = ds_ref_ret.ManagedObjectReference[0]

+            ds_browser = vim_util.get_dynamic_property(

+                                       self._session._get_vim(),

+                                       ds_ref,

+                                       "Datastore",

+                                       "browser")

+            # Check if the vmware-tmp folder exists or not. If not, create one

+            tmp_folder_path = vm_util.build_datastore_path(datastore_name,

+                                                           "vmware-tmp")

+            if not self._path_exists(ds_browser, tmp_folder_path):

+                self._mkdir(vm_util.build_datastore_path(datastore_name,

+                                                         "vmware-tmp"))

+

+        _check_if_tmp_folder_exists()

+

+        # Generate a random vmdk file name to which the coalesced vmdk content

+        # will be copied to. A random name is chosen so that we don't have

+        # name clashes.

+        random_name = str(uuid.uuid4())

+        dest_vmdk_file_location = vm_util.build_datastore_path(datastore_name,

+                   "vmware-tmp/%s.vmdk" % random_name)

+        dc_ref = self._get_datacenter_name_and_ref()[0]

+

+        def _copy_vmdk_content():

+            # Copy the contents of the disk ( or disks, if there were snapshots

+            # done earlier) to a temporary vmdk file.

+            copy_spec = vm_util.get_copy_virtual_disk_spec(client_factory,

+                                                            adapter_type)

+            LOG.debug(_("Copying disk data before snapshot of the VM "

+                        " instance %s") % instance.name)

+            copy_disk_task = self._session._call_method(

+                self._session._get_vim(),

+                "CopyVirtualDisk_Task",

+                service_content.virtualDiskManager,

+                sourceName=vmdk_file_path_before_snapshot,

+                sourceDatacenter=dc_ref,

+                destName=dest_vmdk_file_location,

+                destDatacenter=dc_ref,

+                destSpec=copy_spec,

+                force=False)

+            self._session._wait_for_task(instance.id, copy_disk_task)

+            LOG.debug(_("Copied disk data before snapshot of the VM "

+                        "instance %s") % instance.name)

+

+        _copy_vmdk_content()

+

+        cookies = self._session._get_vim().client.options.transport.cookiejar

+

+        def _upload_vmdk_to_image_repository():

+            # Upload the contents of -flat.vmdk file which has the disk data.

+            LOG.debug(_("Uploading image %s") % snapshot_name)

+            vmware_images.upload_image(

+                snapshot_name,

+                instance,

+                os_type=os_type,

+                adapter_type=adapter_type,

+                image_version=1,

+                host=self._session._host_ip,

+                data_center_name=self._get_datacenter_name_and_ref()[1],

+                datastore_name=datastore_name,

+                cookies=cookies,

+                file_path="vmware-tmp/%s-flat.vmdk" % random_name)

+            LOG.debug(_("Uploaded image %s") % snapshot_name)

+

+        _upload_vmdk_to_image_repository()

+

+        def _clean_temp_data():

+            """

+            Delete temporary vmdk files generated in image handling

+            operations.

+            """

+            # Delete the temporary vmdk created above.

+            LOG.debug(_("Deleting temporary vmdk file %s")

+                        % dest_vmdk_file_location)

+            remove_disk_task = self._session._call_method(

+                self._session._get_vim(),

+                "DeleteVirtualDisk_Task",

+                service_content.virtualDiskManager,

+                name=dest_vmdk_file_location,

+                datacenter=dc_ref)

+            self._session._wait_for_task(instance.id, remove_disk_task)

+            LOG.debug(_("Deleted temporary vmdk file %s")

+                        % dest_vmdk_file_location)

+

+        _clean_temp_data()

+

+    def reboot(self, instance):

+        """Reboot a VM instance."""

+        vm_ref = self._get_vm_ref_from_the_name(instance.name)

+        if vm_ref is None:

+            raise exception.NotFound(_("instance - %s not present") %

+                                     instance.name)

+        lst_properties = ["summary.guest.toolsStatus", "runtime.powerState",

+                          "summary.guest.toolsRunningStatus"]

+        props = self._session._call_method(vim_util, "get_object_properties",

+                           None, vm_ref, "VirtualMachine",

+                           lst_properties)

+        pwr_state = None

+        tools_status = None

+        tools_running_status = False

+        for elem in props:

+            for prop in elem.propSet:

+                if prop.name == "runtime.powerState":

+                    pwr_state = prop.val

+                elif prop.name == "summary.guest.toolsStatus":

+                    tools_status = prop.val

+                elif prop.name == "summary.guest.toolsRunningStatus":

+                    tools_running_status = prop.val

+

+        # Raise an exception if the VM is not powered On.

+        if pwr_state not in ["poweredOn"]:

+            raise exception.Invalid(_("instance - %s not poweredOn. So can't "

+                            "be rebooted.") % instance.name)

+

+        # If latest vmware tools are installed in the VM, and that the tools

+        # are running, then only do a guest reboot. Otherwise do a hard reset.

+        if (tools_status == "toolsOk" and

+                tools_running_status == "guestToolsRunning"):

+            LOG.debug(_("Rebooting guest OS of VM %s") % instance.name)

+            self._session._call_method(self._session._get_vim(), "RebootGuest",

+                                       vm_ref)

+            LOG.debug(_("Rebooted guest OS of VM %s") % instance.name)

+        else:

+            LOG.debug(_("Doing hard reboot of VM %s") % instance.name)

+            reset_task = self._session._call_method(self._session._get_vim(),

+                                                    "ResetVM_Task", vm_ref)

+            self._session._wait_for_task(instance.id, reset_task)

+            LOG.debug(_("Did hard reboot of VM %s") % instance.name)

+

+    def destroy(self, instance):

+        """

+        Destroy a VM instance. Steps followed are:

+        1. Power off the VM, if it is in poweredOn state.

+        2. Un-register a VM.

+        3. Delete the contents of the folder holding the VM related data.

+        """

+        try:

+            vm_ref = self._get_vm_ref_from_the_name(instance.name)

+            if vm_ref is None:

+                LOG.debug(_("instance - %s not present") % instance.name)

+                return

+            lst_properties = ["config.files.vmPathName", "runtime.powerState"]

+            props = self._session._call_method(vim_util,

+                        "get_object_properties",

+                        None, vm_ref, "VirtualMachine", lst_properties)

+            pwr_state = None

+            for elem in props:

+                vm_config_pathname = None

+                for prop in elem.propSet:

+                    if prop.name == "runtime.powerState":

+                        pwr_state = prop.val

+                    elif prop.name == "config.files.vmPathName":

+                        vm_config_pathname = prop.val

+            if vm_config_pathname:

+                datastore_name, vmx_file_path = \

+                            vm_util.split_datastore_path(vm_config_pathname)

+            # Power off the VM if it is in PoweredOn state.

+            if pwr_state == "poweredOn":

+                LOG.debug(_("Powering off the VM %s") % instance.name)

+                poweroff_task = self._session._call_method(

+                       self._session._get_vim(),

+                       "PowerOffVM_Task", vm_ref)

+                self._session._wait_for_task(instance.id, poweroff_task)

+                LOG.debug(_("Powered off the VM %s") % instance.name)

+

+            # Un-register the VM

+            try:

+                LOG.debug(_("Unregistering the VM %s") % instance.name)

+                self._session._call_method(self._session._get_vim(),

+                        "UnregisterVM", vm_ref)

+                LOG.debug(_("Unregistered the VM %s") % instance.name)

+            except Exception, excep:

+                LOG.warn(_("In vmwareapi:vmops:destroy, got this exception"

+                           " while un-registering the VM: %s") % str(excep))

+

+            # Delete the folder holding the VM related content on

+            # the datastore.

+            try:

+                dir_ds_compliant_path = vm_util.build_datastore_path(

+                                 datastore_name,

+                                 os.path.dirname(vmx_file_path))

+                LOG.debug(_("Deleting contents of the VM %(name)s from "

+                            "datastore %(datastore_name)s") %

+                           ({'name': instance.name,

+                             'datastore_name': datastore_name}))

+                delete_task = self._session._call_method(

+                    self._session._get_vim(),

+                    "DeleteDatastoreFile_Task",

+                    self._session._get_vim().get_service_content().fileManager,

+                    name=dir_ds_compliant_path)

+                self._session._wait_for_task(instance.id, delete_task)

+                LOG.debug(_("Deleted contents of the VM %(name)s from "

+                            "datastore %(datastore_name)s") %

+                           ({'name': instance.name,

+                             'datastore_name': datastore_name}))

+            except Exception, excep:

+                LOG.warn(_("In vmwareapi:vmops:destroy, "

+                             "got this exception while deleting"

+                             " the VM contents from the disk: %s")

+                             % str(excep))

+        except Exception, exc:

+            LOG.exception(exc)

+

+    def pause(self, instance, callback):

+        """Pause a VM instance."""

+        raise exception.APIError("pause not supported for vmwareapi")

+

+    def unpause(self, instance, callback):

+        """Un-Pause a VM instance."""

+        raise exception.APIError("unpause not supported for vmwareapi")

+

+    def suspend(self, instance, callback):

+        """Suspend the specified instance."""

+        vm_ref = self._get_vm_ref_from_the_name(instance.name)

+        if vm_ref is None:

+            raise exception.NotFound(_("instance - %s not present") %

+                                     instance.name)

+

+        pwr_state = self._session._call_method(vim_util,

+                    "get_dynamic_property", vm_ref,

+                    "VirtualMachine", "runtime.powerState")

+        # Only PoweredOn VMs can be suspended.

+        if pwr_state == "poweredOn":

+            LOG.debug(_("Suspending the VM %s ") % instance.name)

+            suspend_task = self._session._call_method(self._session._get_vim(),

+                    "SuspendVM_Task", vm_ref)

+            self._wait_with_callback(instance.id, suspend_task, callback)

+            LOG.debug(_("Suspended the VM %s ") % instance.name)

+        # Raise Exception if VM is poweredOff

+        elif pwr_state == "poweredOff":

+            raise exception.Invalid(_("instance - %s is poweredOff and hence "

+                            " can't be suspended.") % instance.name)

+        LOG.debug(_("VM %s was already in suspended state. So returning "

+                    "without doing anything") % instance.name)

+

+    def resume(self, instance, callback):

+        """Resume the specified instance."""

+        vm_ref = self._get_vm_ref_from_the_name(instance.name)

+        if vm_ref is None:

+            raise exception.NotFound(_("instance - %s not present") %

+                                     instance.name)

+

+        pwr_state = self._session._call_method(vim_util,

+                                     "get_dynamic_property", vm_ref,

+                                     "VirtualMachine", "runtime.powerState")

+        if pwr_state.lower() == "suspended":

+            LOG.debug(_("Resuming the VM %s") % instance.name)

+            suspend_task = self._session._call_method(

+                                        self._session._get_vim(),

+                                       "PowerOnVM_Task", vm_ref)

+            self._wait_with_callback(instance.id, suspend_task, callback)

+            LOG.debug(_("Resumed the VM %s ") % instance.name)

+        else:

+            raise exception.Invalid(_("instance - %s not in Suspended state "

+                            "and hence can't be Resumed.") % instance.name)

+

+    def get_info(self, instance_name):

+        """Return data about the VM instance."""

+        vm_ref = self._get_vm_ref_from_the_name(instance_name)

+        if vm_ref is None:

+            raise exception.NotFound(_("instance - %s not present") %

+                                     instance_name)

+

+        lst_properties = ["summary.config.numCpu",

+                    "summary.config.memorySizeMB",

+                    "runtime.powerState"]

+        vm_props = self._session._call_method(vim_util,

+                    "get_object_properties", None, vm_ref, "VirtualMachine",

+                    lst_properties)

+        max_mem = None

+        pwr_state = None

+        num_cpu = None

+        for elem in vm_props:

+            for prop in elem.propSet:

+                if prop.name == "summary.config.numCpu":

+                    num_cpu = int(prop.val)

+                elif prop.name == "summary.config.memorySizeMB":

+                    # In MB, but we want in KB

+                    max_mem = int(prop.val) * 1024

+                elif prop.name == "runtime.powerState":

+                    pwr_state = VMWARE_POWER_STATES[prop.val]

+

+        return {'state': pwr_state,

+                'max_mem': max_mem,

+                'mem': max_mem,

+                'num_cpu': num_cpu,

+                'cpu_time': 0}

+

+    def get_diagnostics(self, instance):

+        """Return data about VM diagnostics."""

+        raise exception.APIError("get_diagnostics not implemented for "

+                                 "vmwareapi")

+

+    def get_console_output(self, instance):

+        """Return snapshot of console."""

+        vm_ref = self._get_vm_ref_from_the_name(instance.name)

+        if vm_ref is None:

+            raise exception.NotFound(_("instance - %s not present") %

+                                     instance.name)

+        param_list = {"id": str(vm_ref)}

+        base_url = "%s://%s/screen?%s" % (self._session._scheme,

+                                         self._session._host_ip,

+                                         urllib.urlencode(param_list))

+        request = urllib2.Request(base_url)

+        base64string = base64.encodestring(

+                        '%s:%s' % (

+                        self._session._host_username,

+                        self._session._host_password)).replace('\n', '')

+        request.add_header("Authorization", "Basic %s" % base64string)

+        result = urllib2.urlopen(request)

+        if result.code == 200:

+            return result.read()

+        else:

+            return ""

+

+    def get_ajax_console(self, instance):

+        """Return link to instance's ajax console."""

+        return 'http://fakeajaxconsole/fake_url'

+

+    def _set_machine_id(self, client_factory, instance):

+        """

+        Set the machine id of the VM for guest tools to pick up and change

+        the IP.

+        """

+        vm_ref = self._get_vm_ref_from_the_name(instance.name)

+        if vm_ref is None:

+            raise exception.NotFound(_("instance - %s not present") %

+                                     instance.name)

+        network = db.network_get_by_instance(context.get_admin_context(),

+                                            instance['id'])

+        mac_addr = instance.mac_address

+        net_mask = network["netmask"]

+        gateway = network["gateway"]

+        ip_addr = db.instance_get_fixed_address(context.get_admin_context(),

+                                            instance['id'])

+        machine_id_chanfge_spec = \

+            vm_util.get_machine_id_change_spec(client_factory, mac_addr,

+                                        ip_addr, net_mask, gateway)

+        LOG.debug(_("Reconfiguring VM instance %(name)s to set the machine id "

+                  "with ip - %(ip_addr)s") %

+                  ({'name': instance.name,

+                   'ip_addr': ip_addr}))

+        reconfig_task = self._session._call_method(self._session._get_vim(),

+                           "ReconfigVM_Task", vm_ref,

+                           spec=machine_id_chanfge_spec)

+        self._session._wait_for_task(instance.id, reconfig_task)

+        LOG.debug(_("Reconfigured VM instance %(name)s to set the machine id "

+                  "with ip - %(ip_addr)s") %

+                  ({'name': instance.name,

+                   'ip_addr': ip_addr}))

+

+    def _get_datacenter_name_and_ref(self):

+        """Get the datacenter name and the reference."""

+        dc_obj = self._session._call_method(vim_util, "get_objects",

+                "Datacenter", ["name"])

+        return dc_obj[0].obj, dc_obj[0].propSet[0].val

+

+    def _path_exists(self, ds_browser, ds_path):

+        """Check if the path exists on the datastore."""

+        search_task = self._session._call_method(self._session._get_vim(),

+                                   "SearchDatastore_Task",

+                                   ds_browser,

+                                   datastorePath=ds_path)

+        # Wait till the state changes from queued or running.

+        # If an error state is returned, it means that the path doesn't exist.

+        while True:

+            task_info = self._session._call_method(vim_util,

+                                       "get_dynamic_property",

+                                       search_task, "Task", "info")

+            if task_info.state in  ['queued', 'running']:

+                time.sleep(2)

+                continue

+            break

+        if task_info.state == "error":

+            return False

+        return True

+

+    def _mkdir(self, ds_path):

+        """

+        Creates a directory at the path specified. If it is just "NAME",

+        then a directory with this name is created at the topmost level of the

+        DataStore.

+        """

+        LOG.debug(_("Creating directory with path %s") % ds_path)

+        self._session._call_method(self._session._get_vim(), "MakeDirectory",

+                    self._session._get_vim().get_service_content().fileManager,

+                    name=ds_path, createParentDirectories=False)

+        LOG.debug(_("Created directory with path %s") % ds_path)

+

+    def _get_vm_ref_from_the_name(self, vm_name):

+        """Get reference to the VM with the name specified."""

+        vms = self._session._call_method(vim_util, "get_objects",

+                    "VirtualMachine", ["name"])

+        for vm in vms:

+            if vm.propSet[0].val == vm_name:

+                return vm.obj

+        return None

diff --git a/nova/virt/vmwareapi/vmware_images.py b/nova/virt/vmwareapi/vmware_images.py
new file mode 100644
index 000000000..50c6baedf
--- /dev/null
+++ b/nova/virt/vmwareapi/vmware_images.py
@@ -0,0 +1,201 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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.

+"""

+Utility functions for Image transfer.

+"""

+

+from glance import client

+

+from nova import exception

+from nova import flags

+from nova import log as logging

+from nova.virt.vmwareapi import io_util

+from nova.virt.vmwareapi import read_write_util

+

+LOG = logging.getLogger("nova.virt.vmwareapi.vmware_images")

+

+FLAGS = flags.FLAGS

+

+QUEUE_BUFFER_SIZE = 10

+

+

+def start_transfer(read_file_handle, data_size, write_file_handle=None,

+                   glance_client=None, image_id=None, image_meta={}):

+    """Start the data transfer from the reader to the writer.

+    Reader writes to the pipe and the writer reads from the pipe. This means

+    that the total transfer time boils down to the slower of the read/write

+    and not the addition of the two times."""

+    # The pipe that acts as an intermediate store of data for reader to write

+    # to and writer to grab from.

+    thread_safe_pipe = io_util.ThreadSafePipe(QUEUE_BUFFER_SIZE, data_size)

+    # The read thread. In case of glance it is the instance of the

+    # GlanceFileRead class. The glance client read returns an iterator

+    # and this class wraps that iterator to provide datachunks in calls

+    # to read.

+    read_thread = io_util.IOThread(read_file_handle, thread_safe_pipe)

+

+    # In case of Glance - VMWare transfer, we just need a handle to the

+    # HTTP Connection that is to send transfer data to the VMWare datastore.

+    if write_file_handle:

+        write_thread = io_util.IOThread(thread_safe_pipe, write_file_handle)

+    # In case of VMWare - Glance transfer, we relinquish VMWare HTTP file read

+    # handle to Glance Client instance, but to be sure of the transfer we need

+    # to be sure of the status of the image on glnace changing to active.

+    # The GlanceWriteThread handles the same for us.

+    elif glance_client and image_id:

+        write_thread = io_util.GlanceWriteThread(thread_safe_pipe,

+                                         glance_client, image_id, image_meta)

+    # Start the read and write threads.

+    read_event = read_thread.start()

+    write_event = write_thread.start()

+    try:

+        # Wait on the read and write events to signal their end

+        read_event.wait()

+        write_event.wait()

+    except Exception, exc:

+        # In case of any of the reads or writes raising an exception,

+        # stop the threads so that we un-necessarily don't keep the other one

+        # waiting.

+        read_thread.stop()

+        write_thread.stop()

+

+        # Log and raise the exception.

+        LOG.exception(exc)

+        raise exception.Error(exc)

+    finally:

+        # No matter what, try closing the read and write handles, if it so

+        # applies.

+        read_file_handle.close()

+        if write_file_handle:

+            write_file_handle.close()

+

+

+def fetch_image(image, instance, **kwargs):

+    """Fetch an image for attaching to the newly created VM."""

+    # Depending upon the image service, make appropriate image service call

+    if FLAGS.image_service == "nova.image.glance.GlanceImageService":

+        func = _get_glance_image

+    elif FLAGS.image_service == "nova.image.s3.S3ImageService":

+        func = _get_s3_image

+    elif FLAGS.image_service == "nova.image.local.LocalImageService":

+        func = _get_local_image

+    else:

+        raise NotImplementedError(_("The Image Service %s is not implemented")

+                                  % FLAGS.image_service)

+    return func(image, instance, **kwargs)

+

+

+def upload_image(image, instance, **kwargs):

+    """Upload the newly snapshotted VM disk file."""

+    # Depending upon the image service, make appropriate image service call

+    if FLAGS.image_service == "nova.image.glance.GlanceImageService":

+        func = _put_glance_image

+    elif FLAGS.image_service == "nova.image.s3.S3ImageService":

+        func = _put_s3_image

+    elif FLAGS.image_service == "nova.image.local.LocalImageService":

+        func = _put_local_image

+    else:

+        raise NotImplementedError(_("The Image Service %s is not implemented")

+                                  % FLAGS.image_service)

+    return func(image, instance, **kwargs)

+

+

+def _get_glance_image(image, instance, **kwargs):

+    """Download image from the glance image server."""

+    LOG.debug(_("Downloading image %s from glance image server") % image)

+    glance_client = client.Client(FLAGS.glance_host, FLAGS.glance_port)

+    metadata, read_iter = glance_client.get_image(image)

+    read_file_handle = read_write_util.GlanceFileRead(read_iter)

+    file_size = int(metadata['size'])

+    write_file_handle = read_write_util.VMWareHTTPWriteFile(

+                                kwargs.get("host"),

+                                kwargs.get("data_center_name"),

+                                kwargs.get("datastore_name"),

+                                kwargs.get("cookies"),

+                                kwargs.get("file_path"),

+                                file_size)

+    start_transfer(read_file_handle, file_size,

+                   write_file_handle=write_file_handle)

+    LOG.debug(_("Downloaded image %s from glance image server") % image)

+

+

+def _get_s3_image(image, instance, **kwargs):

+    """Download image from the S3 image server."""

+    raise NotImplementedError

+

+

+def _get_local_image(image, instance, **kwargs):

+    """Download image from the local nova compute node."""

+    raise NotImplementedError

+

+

+def _put_glance_image(image, instance, **kwargs):

+    """Upload the snapshotted vm disk file to Glance image server."""

+    LOG.debug(_("Uploading image %s to the Glance image server") % image)

+    read_file_handle = read_write_util.VmWareHTTPReadFile(

+                                kwargs.get("host"),

+                                kwargs.get("data_center_name"),

+                                kwargs.get("datastore_name"),

+                                kwargs.get("cookies"),

+                                kwargs.get("file_path"))

+    file_size = read_file_handle.get_size()

+    glance_client = client.Client(FLAGS.glance_host, FLAGS.glance_port)

+    # The properties and other fields that we need to set for the image.

+    image_metadata = {"is_public": True,

+                      "disk_format": "vmdk",

+                      "container_format": "bare",

+                      "type": "vmdk",

+                      "properties": {"vmware_adaptertype":

+                                            kwargs.get("adapter_type"),

+                                     "vmware_ostype": kwargs.get("os_type"),

+                                     "vmware_image_version":

+                                            kwargs.get("image_version")}}

+    start_transfer(read_file_handle, file_size, glance_client=glance_client,

+                        image_id=image, image_meta=image_metadata)

+    LOG.debug(_("Uploaded image %s to the Glance image server") % image)

+

+

+def _put_local_image(image, instance, **kwargs):

+    """Upload the snapshotted vm disk file to the local nova compute node."""

+    raise NotImplementedError

+

+

+def _put_s3_image(image, instance, **kwargs):

+    """Upload the snapshotted vm disk file to S3 image server."""

+    raise NotImplementedError

+

+

+def get_vmdk_size_and_properties(image, instance):

+    """

+    Get size of the vmdk file that is to be downloaded for attach in spawn.

+    Need this to create the dummy virtual disk for the meta-data file. The

+    geometry of the disk created depends on the size.

+    """

+

+    LOG.debug(_("Getting image size for the image %s") % image)

+    if FLAGS.image_service == "nova.image.glance.GlanceImageService":

+        glance_client = client.Client(FLAGS.glance_host,

+                                             FLAGS.glance_port)

+        meta_data = glance_client.get_image_meta(image)

+        size, properties = meta_data["size"], meta_data["properties"]

+    elif FLAGS.image_service == "nova.image.s3.S3ImageService":

+        raise NotImplementedError

+    elif FLAGS.image_service == "nova.image.local.LocalImageService":

+        raise NotImplementedError

+    LOG.debug(_("Got image size of %(size)s for the image %(image)s") %

+              locals())

+    return size, properties

diff --git a/nova/virt/vmwareapi_conn.py b/nova/virt/vmwareapi_conn.py
new file mode 100644
index 000000000..87c3fa299
--- /dev/null
+++ b/nova/virt/vmwareapi_conn.py
@@ -0,0 +1,375 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4

+

+# Copyright (c) 2011 Citrix Systems, Inc.

+# Copyright 2011 OpenStack LLC.

+#

+#    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 the VMware ESX platform.

+

+**Related Flags**

+

+:vmwareapi_host_ip:        IPAddress of VMware ESX server.

+:vmwareapi_host_username:  Username for connection to VMware ESX Server.

+:vmwareapi_host_password:  Password for connection to VMware ESX Server.

+:vmwareapi_task_poll_interval:  The interval (seconds) used for polling of

+                             remote tasks

+                             (default: 1.0).

+:vmwareapi_api_retry_count:  The API retry count in case of failure such as

+                             network failures (socket errors etc.)

+                             (default: 10).

+

+"""

+

+import time

+

+from eventlet import event

+

+from nova import context

+from nova import db

+from nova import exception

+from nova import flags

+from nova import log as logging

+from nova import utils

+from nova.virt.vmwareapi import error_util

+from nova.virt.vmwareapi import vim

+from nova.virt.vmwareapi import vim_util

+from nova.virt.vmwareapi.vmops import VMWareVMOps

+

+LOG = logging.getLogger("nova.virt.vmwareapi_conn")

+

+FLAGS = flags.FLAGS

+flags.DEFINE_string('vmwareapi_host_ip',

+                    None,

+                    'URL for connection to VMWare ESX host.'

+                    'Required if connection_type is vmwareapi.')

+flags.DEFINE_string('vmwareapi_host_username',

+                    None,

+                    'Username for connection to VMWare ESX host.'

+                    'Used only if connection_type is vmwareapi.')

+flags.DEFINE_string('vmwareapi_host_password',

+                    None,

+                    'Password for connection to VMWare ESX host.'

+                    'Used only if connection_type is vmwareapi.')

+flags.DEFINE_float('vmwareapi_task_poll_interval',

+                   5.0,

+                   'The interval used for polling of remote tasks '

+                   'Used only if connection_type is vmwareapi')

+flags.DEFINE_float('vmwareapi_api_retry_count',

+                   10,

+                   'The number of times we retry on failures, '

+                   'e.g., socket error, etc.'

+                   'Used only if connection_type is vmwareapi')

+flags.DEFINE_string('vmwareapi_vlan_interface',

+                   'vmnic0',

+                   'Physical ethernet adapter name for vlan networking')

+

+TIME_BETWEEN_API_CALL_RETRIES = 2.0

+

+

+class Failure(Exception):

+    """Base Exception class for handling task failures."""

+

+    def __init__(self, details):

+        self.details = details

+

+    def __str__(self):

+        return str(self.details)

+

+

+def get_connection(_):

+    """Sets up the ESX host connection."""

+    host_ip = FLAGS.vmwareapi_host_ip

+    host_username = FLAGS.vmwareapi_host_username

+    host_password = FLAGS.vmwareapi_host_password

+    api_retry_count = FLAGS.vmwareapi_api_retry_count

+    if not host_ip or host_username is None or host_password is None:

+        raise Exception(_("Must specify vmwareapi_host_ip,"

+                        "vmwareapi_host_username "

+                        "and vmwareapi_host_password to use"

+                        "connection_type=vmwareapi"))

+    return VMWareESXConnection(host_ip, host_username, host_password,

+                               api_retry_count)

+

+

+class VMWareESXConnection(object):

+    """The ESX host connection object."""

+

+    def __init__(self, host_ip, host_username, host_password,

+                 api_retry_count, scheme="https"):

+        session = VMWareAPISession(host_ip, host_username, host_password,

+                 api_retry_count, scheme=scheme)

+        self._vmops = VMWareVMOps(session)

+

+    def init_host(self, host):

+        """Do the initialization that needs to be done."""

+        # FIXME(sateesh): implement this

+        pass

+

+    def list_instances(self):

+        """List VM instances."""

+        return self._vmops.list_instances()

+

+    def spawn(self, instance):

+        """Create VM instance."""

+        self._vmops.spawn(instance)

+

+    def snapshot(self, instance, name):

+        """Create snapshot from a running VM instance."""

+        self._vmops.snapshot(instance, name)

+

+    def reboot(self, instance):

+        """Reboot VM instance."""

+        self._vmops.reboot(instance)

+

+    def destroy(self, instance):

+        """Destroy VM instance."""

+        self._vmops.destroy(instance)

+

+    def pause(self, instance, callback):

+        """Pause VM instance."""

+        self._vmops.pause(instance, callback)

+

+    def unpause(self, instance, callback):

+        """Unpause paused VM instance."""

+        self._vmops.unpause(instance, callback)

+

+    def suspend(self, instance, callback):

+        """Suspend the specified instance."""

+        self._vmops.suspend(instance, callback)

+

+    def resume(self, instance, callback):

+        """Resume the suspended VM instance."""

+        self._vmops.resume(instance, callback)

+

+    def get_info(self, instance_id):

+        """Return info about the VM instance."""

+        return self._vmops.get_info(instance_id)

+

+    def get_diagnostics(self, instance):

+        """Return data about VM diagnostics."""

+        return self._vmops.get_info(instance)

+

+    def get_console_output(self, instance):

+        """Return snapshot of console."""

+        return self._vmops.get_console_output(instance)

+

+    def get_ajax_console(self, instance):

+        """Return link to instance's ajax console."""

+        return self._vmops.get_ajax_console(instance)

+

+    def attach_volume(self, instance_name, device_path, mountpoint):

+        """Attach volume storage to VM instance."""

+        pass

+

+    def detach_volume(self, instance_name, mountpoint):

+        """Detach volume storage to VM instance."""

+        pass

+

+    def get_console_pool_info(self, console_type):

+        """Get info about the host on which the VM resides."""

+        return {'address': FLAGS.vmwareapi_host_ip,

+                'username': FLAGS.vmwareapi_host_username,

+                'password': FLAGS.vmwareapi_host_password}

+

+    def update_available_resource(self, ctxt, host):

+        """This method is supported only by libvirt."""

+        return

+

+

+class VMWareAPISession(object):

+    """

+    Sets up a session with the ESX host and handles all

+    the calls made to the host.

+    """

+

+    def __init__(self, host_ip, host_username, host_password,

+                 api_retry_count, scheme="https"):

+        self._host_ip = host_ip

+        self._host_username = host_username

+        self._host_password = host_password

+        self.api_retry_count = api_retry_count

+        self._scheme = scheme

+        self._session_id = None

+        self.vim = None

+        self._create_session()

+

+    def _get_vim_object(self):

+        """Create the VIM Object instance."""

+        return vim.Vim(protocol=self._scheme, host=self._host_ip)

+

+    def _create_session(self):

+        """Creates a session with the ESX host."""

+        while True:

+            try:

+                # Login and setup the session with the ESX host for making

+                # API calls

+                self.vim = self._get_vim_object()

+                session = self.vim.Login(

+                               self.vim.get_service_content().sessionManager,

+                               userName=self._host_username,

+                               password=self._host_password)

+                # Terminate the earlier session, if possible ( For the sake of

+                # preserving sessions as there is a limit to the number of

+                # sessions we can have )

+                if self._session_id:

+                    try:

+                        self.vim.TerminateSession(

+                                self.vim.get_service_content().sessionManager,

+                                sessionId=[self._session_id])

+                    except Exception, excep:

+                        # This exception is something we can live with. It is

+                        # just an extra caution on our side. The session may

+                        # have been cleared. We could have made a call to

+                        # SessionIsActive, but that is an overhead because we

+                        # anyway would have to call TerminateSession.

+                        LOG.debug(excep)

+                self._session_id = session.key

+                return

+            except Exception, excep:

+                LOG.critical(_("In vmwareapi:_create_session, "

+                              "got this exception: %s") % excep)

+                raise exception.Error(excep)

+

+    def __del__(self):

+        """Logs-out the session."""

+        # Logout to avoid un-necessary increase in session count at the

+        # ESX host

+        try:

+            self.vim.Logout(self.vim.get_service_content().sessionManager)

+        except Exception, excep:

+            # It is just cautionary on our part to do a logout in del just

+            # to ensure that the session is not left active.

+            LOG.debug(excep)

+

+    def _is_vim_object(self, module):

+        """Check if the module is a VIM Object instance."""

+        return isinstance(module, vim.Vim)

+

+    def _call_method(self, module, method, *args, **kwargs):

+        """

+        Calls a method within the module specified with

+        args provided.

+        """

+        args = list(args)

+        retry_count = 0

+        exc = None

+        last_fault_list = []

+        while True:

+            try:

+                if not self._is_vim_object(module):

+                    # If it is not the first try, then get the latest

+                    # vim object

+                    if retry_count > 0:

+                        args = args[1:]

+                    args = [self.vim] + args

+                retry_count += 1

+                temp_module = module

+

+                for method_elem in method.split("."):

+                    temp_module = getattr(temp_module, method_elem)

+

+                return temp_module(*args, **kwargs)

+            except error_util.VimFaultException, excep:

+                # If it is a Session Fault Exception, it may point

+                # to a session gone bad. So we try re-creating a session

+                # and then proceeding ahead with the call.

+                exc = excep

+                if error_util.FAULT_NOT_AUTHENTICATED in excep.fault_list:

+                    # Because of the idle session returning an empty

+                    # RetrievePropertiesResponse and also the same is returned

+                    # when there is say empty answer to the query for

+                    # VMs on the host ( as in no VMs on the host), we have no

+                    # way to differentiate.

+                    # So if the previous response was also am empty response

+                    # and after creating a new session, we get the same empty

+                    # response, then we are sure of the response being supposed

+                    # to be empty.

+                    if error_util.FAULT_NOT_AUTHENTICATED in last_fault_list:

+                        return []

+                    last_fault_list = excep.fault_list

+                    self._create_session()

+                else:

+                    # No re-trying for errors for API call has gone through

+                    # and is the caller's fault. Caller should handle these

+                    # errors. e.g, InvalidArgument fault.

+                    break

+            except error_util.SessionOverLoadException, excep:

+                # For exceptions which may come because of session overload,

+                # we retry

+                exc = excep

+            except Exception, excep:

+                # If it is a proper exception, say not having furnished

+                # proper data in the SOAP call or the retry limit having

+                # exceeded, we raise the exception

+                exc = excep

+                break

+            # If retry count has been reached then break and

+            # raise the exception

+            if retry_count > self.api_retry_count:

+                break

+            time.sleep(TIME_BETWEEN_API_CALL_RETRIES)

+

+        LOG.critical(_("In vmwareapi:_call_method, "

+                     "got this exception: %s") % exc)

+        raise

+

+    def _get_vim(self):

+        """Gets the VIM object reference."""

+        if self.vim is None:

+            self._create_session()

+        return self.vim

+

+    def _wait_for_task(self, instance_id, task_ref):

+        """

+        Return a Deferred that will give the result of the given task.

+        The task is polled until it completes.

+        """

+        done = event.Event()

+        loop = utils.LoopingCall(self._poll_task, instance_id, task_ref,

+                                      done)

+        loop.start(FLAGS.vmwareapi_task_poll_interval, now=True)

+        ret_val = done.wait()

+        loop.stop()

+        return ret_val

+

+    def _poll_task(self, instance_id, task_ref, done):

+        """

+        Poll the given task, and fires the given Deferred if we

+        get a result.

+        """

+        try:

+            task_info = self._call_method(vim_util, "get_dynamic_property",

+                            task_ref, "Task", "info")

+            task_name = task_info.name

+            action = dict(

+                instance_id=int(instance_id),

+                action=task_name[0:255],

+                error=None)

+            if task_info.state in ['queued', 'running']:

+                return

+            elif task_info.state == 'success':

+                LOG.debug(_("Task [%(task_name)s] %(task_ref)s "

+                            "status: success") % locals())

+                done.send("success")

+            else:

+                error_info = str(task_info.error.localizedMessage)

+                action["error"] = error_info

+                LOG.warn(_("Task [%(task_name)s] %(task_ref)s "

+                          "status: error %(error_info)s") % locals())

+                done.send_exception(exception.Error(error_info))

+            db.instance_action_create(context.get_admin_context(), action)

+        except Exception, excep:

+            LOG.warn(_("In vmwareapi:_poll_task, Got this error %s") % excep)

+            done.send_exception(excep)

diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index 28ce215d8..c30e4b2d1 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -991,8 +991,8 @@ def _write_partition(virtual_size, dev):
     def execute(*cmd, **kwargs):
         return utils.execute(*cmd, **kwargs)
 
-    execute('parted', '--script', dest, 'mklabel', 'msdos')
-    execute('parted', '--script', dest, 'mkpart', 'primary',
+    execute('sudo', 'parted', '--script', dest, 'mklabel', 'msdos')
+    execute('sudo', 'parted', '--script', dest, 'mkpart', 'primary',
             '%ds' % primary_first,
             '%ds' % primary_last)
 
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 988f6c2e0..2e1f3ee91 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -117,6 +117,10 @@ class VMOps(object):
         vm_ref = self._create_vm(instance, vdi_uuid, network_info)
         self._spawn(instance, vm_ref)
 
+    def spawn_rescue(self, instance):
+        """Spawn a rescue instance"""
+        self.spawn(instance)
+
     def _create_vm(self, instance, vdi_uuid, network_info=None):
         """Create VM instance"""
         instance_name = instance.name
@@ -543,7 +547,7 @@ class VMOps(object):
         vbd_refs = self._session.get_xenapi().VM.get_VBDs(rescue_vm_ref)
         for vbd_ref in vbd_refs:
             vbd_rec = self._session.get_xenapi().VBD.get_record(vbd_ref)
-            if vbd_rec["userdevice"] == "1":  # primary VBD is always 1
+            if vbd_rec.get("userdevice", None) == "1":  # VBD is always 1
                 VMHelper.unplug_vbd(self._session, vbd_ref)
                 VMHelper.destroy_vbd(self._session, vbd_ref)
 
@@ -680,18 +684,18 @@ class VMOps(object):
 
         """
         rescue_vm_ref = VMHelper.lookup(self._session,
-                                        instance.name + "-rescue")
+                                        "%s-rescue" % instance.name)
         if rescue_vm_ref:
             raise RuntimeError(_(
                 "Instance is already in Rescue Mode: %s" % instance.name))
 
-        vm_ref = self._get_vm_opaque_ref(instance)
+        vm_ref = VMHelper.lookup(self._session, instance.name)
         self._shutdown(instance, vm_ref)
         self._acquire_bootlock(vm_ref)
 
         instance._rescue = True
-        self.spawn(instance)
-        rescue_vm_ref = self._get_vm_opaque_ref(instance)
+        self.spawn_rescue(instance)
+        rescue_vm_ref = VMHelper.lookup(self._session, instance.name)
 
         vbd_ref = self._session.get_xenapi().VM.get_VBDs(vm_ref)[0]
         vdi_ref = self._session.get_xenapi().VBD.get_record(vbd_ref)["VDI"]
@@ -708,13 +712,13 @@ class VMOps(object):
 
         """
         rescue_vm_ref = VMHelper.lookup(self._session,
-                                        instance.name + "-rescue")
+                                        "%s-rescue" % instance.name)
 
         if not rescue_vm_ref:
             raise exception.NotFound(_(
                 "Instance is not in Rescue Mode: %s" % instance.name))
 
-        original_vm_ref = self._get_vm_opaque_ref(instance)
+        original_vm_ref = VMHelper.lookup(self._session, instance.name)
         instance._rescue = False
 
         self._destroy_rescue_instance(rescue_vm_ref)
@@ -727,24 +731,24 @@ class VMOps(object):
               in rescue mode for >= the provided timeout
         """
         last_ran = self.poll_rescue_last_ran
-        if last_ran:
-            if not utils.is_older_than(last_ran, timeout):
-                # Do not run. Let's bail.
-                return
-            else:
-                # Update the time tracker and proceed.
-                self.poll_rescue_last_ran = utils.utcnow()
-        else:
+        if not last_ran:
             # We need a base time to start tracking.
             self.poll_rescue_last_ran = utils.utcnow()
             return
 
+        if not utils.is_older_than(last_ran, timeout):
+            # Do not run. Let's bail.
+            return
+
+        # Update the time tracker and proceed.
+        self.poll_rescue_last_ran = utils.utcnow()
+
         rescue_vms = []
         for instance in self.list_instances():
             if instance.endswith("-rescue"):
                 rescue_vms.append(dict(name=instance,
-                                  vm_ref=VMHelper.lookup(self._session,
-                                                         instance)))
+                                       vm_ref=VMHelper.lookup(self._session,
+                                                              instance)))
 
         for vm in rescue_vms:
             rescue_name = vm["name"]