Merged trunk.

9 files changed, 148 insertions, 181 deletions

diff --git a/nova/virt/fake.py b/nova/virt/fake.py
index c3d5230df..33f37b512 100644
--- a/nova/virt/fake.py
+++ b/nova/virt/fake.py
@@ -288,8 +288,7 @@ class FakeConnection(driver.ComputeDriver):
         knowledge of the instance
         """
         if instance_name not in self.instances:
-            raise exception.NotFound(_("Instance %s Not Found")
-                                     % instance_name)
+            raise exception.InstanceNotFound(instance_id=instance_name)
         i = self.instances[instance_name]
         return {'state': i.state,
                 'max_mem': 0,
diff --git a/nova/virt/hyperv.py b/nova/virt/hyperv.py
index 13f403a66..9026e737e 100644
--- a/nova/virt/hyperv.py
+++ b/nova/virt/hyperv.py
@@ -143,8 +143,7 @@ class HyperVConnection(driver.ComputeDriver):
         """ Create a new VM and start it."""
         vm = self._lookup(instance.name)
         if vm is not None:
-            raise exception.Duplicate(_('Attempt to create duplicate vm %s') %
-                    instance.name)
+            raise exception.InstanceExists(name=instance.name)
 
         user = manager.AuthManager().get_user(instance['user_id'])
         project = manager.AuthManager().get_project(instance['project_id'])
@@ -368,7 +367,7 @@ class HyperVConnection(driver.ComputeDriver):
         """Reboot the specified instance."""
         vm = self._lookup(instance.name)
         if vm is None:
-            raise exception.NotFound('instance not present %s' % instance.name)
+            raise exception.InstanceNotFound(instance_id=instance.id)
         self._set_vm_state(instance.name, 'Reboot')
 
     def destroy(self, instance):
@@ -412,7 +411,7 @@ class HyperVConnection(driver.ComputeDriver):
         """Get information about the VM"""
         vm = self._lookup(instance_id)
         if vm is None:
-            raise exception.NotFound('instance not present %s' % instance_id)
+            raise exception.InstanceNotFound(instance_id=instance_id)
         vm = self._conn.Msvm_ComputerSystem(ElementName=instance_id)[0]
         vs_man_svc = self._conn.Msvm_VirtualSystemManagementService()[0]
         vmsettings = vm.associators(
@@ -474,14 +473,12 @@ class HyperVConnection(driver.ComputeDriver):
     def attach_volume(self, instance_name, device_path, mountpoint):
         vm = self._lookup(instance_name)
         if vm is None:
-            raise exception.NotFound('Cannot attach volume to missing %s vm'
-                    % instance_name)
+            raise exception.InstanceNotFound(instance_id=instance_name)
 
     def detach_volume(self, instance_name, mountpoint):
         vm = self._lookup(instance_name)
         if vm is None:
-            raise exception.NotFound('Cannot detach volume from missing %s '
-                    % instance_name)
+            raise exception.InstanceNotFound(instance_id=instance_name)
 
     def poll_rescued_instances(self, timeout):
         pass
diff --git a/nova/virt/libvirt/connection.py b/nova/virt/libvirt/connection.py
index 4eb8e3167..e9ed88a3d 100644
--- a/nova/virt/libvirt/connection.py
+++ b/nova/virt/libvirt/connection.py
@@ -374,7 +374,7 @@ class LibvirtConnection(driver.ComputeDriver):
         mount_device = mountpoint.rpartition("/")[2]
         xml = self._get_disk_xml(virt_dom.XMLDesc(0), mount_device)
         if not xml:
-            raise exception.NotFound(_("No disk at %s") % mount_device)
+            raise exception.DiskNotFound(location=mount_device)
         virt_dom.detachDevice(xml)
 
     @exception.wrap_exception
@@ -561,7 +561,7 @@ class LibvirtConnection(driver.ComputeDriver):
         xml = self.to_xml(instance, False, network_info)
         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._create_image(instance, xml, network_info=network_info)
         domain = self._create_new_domain(xml)
         LOG.debug(_("instance %s: is running"), instance['name'])
         self.firewall_driver.apply_instance_filter(instance)
@@ -675,6 +675,9 @@ class LibvirtConnection(driver.ComputeDriver):
         subprocess.Popen(cmd, shell=True)
         return {'token': token, 'host': host, 'port': port}
 
+    def get_host_ip_addr(self):
+        return FLAGS.my_ip
+
     @exception.wrap_exception
     def get_vnc_console(self, instance):
         def get_vnc_port_for_instance(instance_name):
@@ -900,26 +903,16 @@ class LibvirtConnection(driver.ComputeDriver):
         mac_id = mapping['mac'].replace(':', '')
 
         if FLAGS.allow_project_net_traffic:
+            template = "<parameter name=\"%s\"value=\"%s\" />\n"
+            net, mask = netutils.get_net_and_mask(network['cidr'])
+            values = [("PROJNET", net), ("PROJMASK", mask)]
             if FLAGS.use_ipv6:
-                net, mask = netutils.get_net_and_mask(network['cidr'])
                 net_v6, prefixlen_v6 = netutils.get_net_and_prefixlen(
                                            network['cidr_v6'])
-                extra_params = ("<parameter name=\"PROJNET\" "
-                            "value=\"%s\" />\n"
-                            "<parameter name=\"PROJMASK\" "
-                            "value=\"%s\" />\n"
-                            "<parameter name=\"PROJNETV6\" "
-                            "value=\"%s\" />\n"
-                            "<parameter name=\"PROJMASKV6\" "
-                            "value=\"%s\" />\n") % \
-                              (net, mask, net_v6, prefixlen_v6)
-            else:
-                net, mask = netutils.get_net_and_mask(network['cidr'])
-                extra_params = ("<parameter name=\"PROJNET\" "
-                            "value=\"%s\" />\n"
-                            "<parameter name=\"PROJMASK\" "
-                            "value=\"%s\" />\n") % \
-                              (net, mask)
+                values.extend([("PROJNETV6", net_v6),
+                               ("PROJMASKV6", prefixlen_v6)])
+
+            extra_params = "".join([template % value for value in values])
         else:
             extra_params = "\n"
 
@@ -937,10 +930,8 @@ class LibvirtConnection(driver.ComputeDriver):
 
         return result
 
-    def to_xml(self, instance, rescue=False, network_info=None):
-        # TODO(termie): cache?
-        LOG.debug(_('instance %s: starting toXML method'), instance['name'])
 
+    def _prepare_xml_info(self, instance, rescue=False, network_info=None):
         # TODO(adiantum) remove network_info creation code
         # when multinics will be completed
         if not network_info:
@@ -948,8 +939,7 @@ class LibvirtConnection(driver.ComputeDriver):
 
         nics = []
         for (network, mapping) in network_info:
-            nics.append(self._get_nic_for_xml(network,
-                                              mapping))
+            nics.append(self._get_nic_for_xml(network, mapping))
         # FIXME(vish): stick this in db
         inst_type_id = instance['instance_type_id']
         inst_type = instance_types.get_instance_type(inst_type_id)
@@ -981,10 +971,14 @@ class LibvirtConnection(driver.ComputeDriver):
                 xml_info['ramdisk'] = xml_info['basepath'] + "/ramdisk"
 
             xml_info['disk'] = xml_info['basepath'] + "/disk"
+        return xml_info
 
+    def to_xml(self, instance, rescue=False, network_info=None):
+        # TODO(termie): cache?
+        LOG.debug(_('instance %s: starting toXML method'), instance['name'])
+        xml_info = self._prepare_xml_info(instance, rescue, network_info)
         xml = str(Template(self.libvirt_xml, searchList=[xml_info]))
-        LOG.debug(_('instance %s: finished toXML method'),
-                        instance['name'])
+        LOG.debug(_('instance %s: finished toXML method'), instance['name'])
         return xml
 
     def _lookup_by_name(self, instance_name):
@@ -999,8 +993,7 @@ class LibvirtConnection(driver.ComputeDriver):
         except libvirt.libvirtError as ex:
             error_code = ex.get_error_code()
             if error_code == libvirt.VIR_ERR_NO_DOMAIN:
-                msg = _("Instance %s not found") % instance_name
-                raise exception.NotFound(msg)
+                raise exception.InstanceNotFound(instance_id=instance_name)
 
             msg = _("Error from libvirt while looking up %(instance_name)s: "
                     "[Error Code %(error_code)s] %(ex)s") % locals()
diff --git a/nova/virt/libvirt/firewall.py b/nova/virt/libvirt/firewall.py
index 99ba02aaa..618fec8c7 100644
--- a/nova/virt/libvirt/firewall.py
+++ b/nova/virt/libvirt/firewall.py
@@ -40,17 +40,14 @@ except ImportError:
 
 
 class FirewallDriver(object):
-
     def prepare_instance_filter(self, instance, network_info=None):
         """Prepare filters for the instance.
 
-        At this point, the instance isn't running yet.
-
-        """
+        At this point, the instance isn't running yet."""
         raise NotImplementedError()
 
     def unfilter_instance(self, instance):
-        """Stop filtering instance."""
+        """Stop filtering instance"""
         raise NotImplementedError()
 
     def apply_instance_filter(self, instance):
@@ -60,26 +57,21 @@ class FirewallDriver(object):
         appropriately. This method should as far as possible be a
         no-op. It's vastly preferred to get everything set up in
         prepare_instance_filter.
-
         """
         raise NotImplementedError()
 
     def refresh_security_group_rules(self, security_group_id):
-        """Refresh security group rules from data store.
+        """Refresh security group rules from data store
 
         Gets called when a rule has been added to or removed from
-        the security group.
-
-        """
+        the security group."""
         raise NotImplementedError()
 
     def refresh_security_group_members(self, security_group_id):
-        """Refresh security group members from data store.
+        """Refresh security group members from data store
 
         Gets called when an instance gets added to or removed from
-        the security group.
-
-        """
+        the security group."""
         raise NotImplementedError()
 
     def setup_basic_filtering(self, instance, network_info=None):
@@ -92,13 +84,12 @@ class FirewallDriver(object):
         raise NotImplementedError()
 
     def instance_filter_exists(self, instance):
-        """Check nova-instance-instance-xxx exists."""
+        """Check nova-instance-instance-xxx exists"""
         raise NotImplementedError()
 
 
 class NWFilterFirewall(FirewallDriver):
-    """Network filter firewall implementation.
-
+    """
     This class implements a network filtering mechanism versatile
     enough for EC2 style Security Group filtering by leveraging
     libvirt's nwfilter.
@@ -149,46 +140,46 @@ class NWFilterFirewall(FirewallDriver):
         self.handle_security_groups = False
 
     def apply_instance_filter(self, instance):
+        """No-op. Everything is done in prepare_instance_filter"""
         pass
 
     def _get_connection(self):
         return self._libvirt_get_connection()
-
     _conn = property(_get_connection)
 
     def nova_dhcp_filter(self):
-        """Defines nova DHCP filter.
-
-        The standard allow-dhcp-server filter is an <ip> one, so it uses
-        ebtables to allow traffic through. Without a corresponding rule in
-        iptables, it'll get blocked anyway.
+        """The standard allow-dhcp-server filter is an <ip> one, so it uses
+           ebtables to allow traffic through. Without a corresponding rule in
+           iptables, it'll get blocked anyway."""
 
-        """
         return '''<filter name='nova-allow-dhcp-server' chain='ipv4'>
                     <uuid>891e4787-e5c0-d59b-cbd6-41bc3c6b36fc</uuid>
-                    <rule action='accept' direction='out' priority='100'>
-                        <udp srcipaddr='0.0.0.0'
-                             dstipaddr='255.255.255.255'
-                             srcportstart='68'
-                             dstportstart='67'/>
+                    <rule action='accept' direction='out'
+                          priority='100'>
+                      <udp srcipaddr='0.0.0.0'
+                           dstipaddr='255.255.255.255'
+                           srcportstart='68'
+                           dstportstart='67'/>
                     </rule>
-                    <rule action='accept' direction='in' priority='100'>
-                        <udp srcipaddr='$DHCPSERVER'
-                             srcportstart='67'
-                             dstportstart='68'/>
+                    <rule action='accept' direction='in'
+                          priority='100'>
+                      <udp srcipaddr='$DHCPSERVER'
+                           srcportstart='67'
+                           dstportstart='68'/>
                     </rule>
                   </filter>'''
 
     def nova_ra_filter(self):
         return '''<filter name='nova-allow-ra-server' chain='root'>
-                    <uuid>d707fa71-4fb5-4b27-9ab7-ba5ca19c8804</uuid>
-                    <rule action='accept' direction='inout' priority='100'>
-                      <icmpv6 srcipaddr='$RASERVER'/>
-                    </rule>
-                  </filter>'''
+                            <uuid>d707fa71-4fb5-4b27-9ab7-ba5ca19c8804</uuid>
+                              <rule action='accept' direction='inout'
+                                    priority='100'>
+                                <icmpv6 srcipaddr='$RASERVER'/>
+                              </rule>
+                            </filter>'''
 
     def setup_basic_filtering(self, instance, network_info=None):
-        """Set up basic filtering (MAC, IP, and ARP spoofing protection)."""
+        """Set up basic filtering (MAC, IP, and ARP spoofing protection)"""
         logging.info('called setup_basic_filtering in nwfilter')
 
         if not network_info:
@@ -296,18 +287,13 @@ class NWFilterFirewall(FirewallDriver):
         pass
 
     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.
-
+        """
+        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 = netutils.get_network_info(instance)
-        if instance['image_id'] == str(FLAGS.vpn_image_id):
-            base_filter = 'nova-vpn'
-        else:
-            base_filter = 'nova-base'
 
         ctxt = context.get_admin_context()
 
@@ -319,41 +305,59 @@ class NWFilterFirewall(FirewallDriver):
                                              'nova-base-ipv6',
                                              'nova-allow-dhcp-server']
 
+        if FLAGS.use_ipv6:
+            networks = [network for (network, _m) in network_info if
+                        network['gateway_v6']]
+
+            if networks:
+                instance_secgroup_filter_children.\
+                    append('nova-allow-ra-server')
+
         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'])]
+            instance_secgroup_filter_children.append('nova-secgroup-%s' %
+                                                    security_group['id'])
 
             self._define_filter(
                     self._filter_container(instance_secgroup_filter_name,
                                            instance_secgroup_filter_children))
 
-        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]
+        network_filters = self.\
+            _create_network_filters(instance, network_info,
+                                    instance_secgroup_filter_name)
 
-            if FLAGS.use_ipv6:
-                gateway_v6 = network['gateway_v6']
+        for (name, children) in network_filters:
+            self._define_filters(name, children)
 
-                if gateway_v6:
-                    instance_secgroup_filter_children += \
-                        ['nova-allow-ra-server']
+    def _create_network_filters(self, instance, network_info,
+                               instance_secgroup_filter_name):
+        if instance['image_id'] == str(FLAGS.vpn_image_id):
+            base_filter = 'nova-vpn'
+        else:
+            base_filter = 'nova-base'
+
+        result = []
+        for (_n, 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.allow_project_net_traffic:
-                instance_filter_children += ['nova-project']
+                instance_filter_children.append('nova-project')
                 if FLAGS.use_ipv6:
-                    instance_filter_children += ['nova-project-v6']
+                    instance_filter_children.append('nova-project-v6')
 
-            self._define_filter(
-                    self._filter_container(instance_filter_name,
-                                           instance_filter_children))
+            result.append((instance_filter_name, instance_filter_children))
+
+        return result
 
-        return
+    def _define_filters(self, filter_name, filter_children):
+        self._define_filter(self._filter_container(filter_name,
+                                                   filter_children))
 
     def refresh_security_group_rules(self, security_group_id):
         return self._define_filter(
@@ -403,7 +407,7 @@ class NWFilterFirewall(FirewallDriver):
         return 'nova-instance-%s-%s' % (instance['name'], nic_id)
 
     def instance_filter_exists(self, instance):
-        """Check nova-instance-instance-xxx exists."""
+        """Check nova-instance-instance-xxx exists"""
         network_info = netutils.get_network_info(instance)
         for (network, mapping) in network_info:
             nic_id = mapping['mac'].replace(':', '')
@@ -437,7 +441,7 @@ class IptablesFirewallDriver(FirewallDriver):
         return self.nwfilter.setup_basic_filtering(instance, network_info)
 
     def apply_instance_filter(self, instance):
-        """No-op. Everything is done in prepare_instance_filter."""
+        """No-op. Everything is done in prepare_instance_filter"""
         pass
 
     def unfilter_instance(self, instance):
@@ -455,34 +459,23 @@ class IptablesFirewallDriver(FirewallDriver):
         self.add_filters_for_instance(instance, network_info)
         self.iptables.apply()
 
-    def add_filters_for_instance(self, instance, network_info=None):
-        if not network_info:
-            network_info = netutils.get_network_info(instance)
-        chain_name = self._instance_chain_name(instance)
-
-        self.iptables.ipv4['filter'].add_chain(chain_name)
-
-        ips_v4 = [ip['ip'] for (_, mapping) in network_info
-                            for ip in mapping['ips']]
+    def _create_filter(self, ips, chain_name):
+        return ['-d %s -j $%s' % (ip, chain_name) for ip in ips]
 
-        for ipv4_address in ips_v4:
-            self.iptables.ipv4['filter'].add_rule('local',
-                                                  '-d %s -j $%s' %
-                                                  (ipv4_address, chain_name))
+    def _filters_for_instance(self, chain_name, network_info):
+        ips_v4 = [ip['ip'] for (_n, mapping) in network_info
+                 for ip in mapping['ips']]
+        ipv4_rules = self._create_filter(ips_v4, chain_name)
 
+        ipv6_rules = []
         if FLAGS.use_ipv6:
-            self.iptables.ipv6['filter'].add_chain(chain_name)
-            ips_v6 = [ip['ip'] for (_, mapping) in network_info
-                                 for ip in mapping['ip6s']]
+            ips_v6 = [ip['ip'] for (_n, mapping) in network_info
+                     for ip in mapping['ip6s']]
+            ipv6_rules = self._create_filter(ips_v6, chain_name)
 
-            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, network_info)
+        return ipv4_rules, ipv6_rules
 
+    def _add_filters(self, chain_name, ipv4_rules, ipv6_rules):
         for rule in ipv4_rules:
             self.iptables.ipv4['filter'].add_rule(chain_name, rule)
 
@@ -490,6 +483,17 @@ class IptablesFirewallDriver(FirewallDriver):
             for rule in ipv6_rules:
                 self.iptables.ipv6['filter'].add_rule(chain_name, rule)
 
+    def add_filters_for_instance(self, instance, network_info=None):
+        chain_name = self._instance_chain_name(instance)
+        if FLAGS.use_ipv6:
+            self.iptables.ipv6['filter'].add_chain(chain_name)
+        self.iptables.ipv4['filter'].add_chain(chain_name)
+        ipv4_rules, ipv6_rules = self._filters_for_instance(chain_name,
+                                                            network_info)
+        self._add_filters('local', ipv4_rules, ipv6_rules)
+        ipv4_rules, ipv6_rules = self.instance_rules(instance, network_info)
+        self._add_filters(chain_name, ipv4_rules, ipv6_rules)
+
     def remove_filters_for_instance(self, instance):
         chain_name = self._instance_chain_name(instance)
 
@@ -607,7 +611,7 @@ class IptablesFirewallDriver(FirewallDriver):
         return ipv4_rules, ipv6_rules
 
     def instance_filter_exists(self, instance):
-        """Check nova-instance-instance-xxx exists."""
+        """Check nova-instance-instance-xxx exists"""
         return self.nwfilter.instance_filter_exists(instance)
 
     def refresh_security_group_members(self, security_group):
diff --git a/nova/virt/vmwareapi/fake.py b/nova/virt/vmwareapi/fake.py
index 4bb467fa9..7370684bd 100644
--- a/nova/virt/vmwareapi/fake.py
+++ b/nova/virt/vmwareapi/fake.py
@@ -387,12 +387,11 @@ def _add_file(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"))

+        raise exception.NoFilesFound()

     # 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)

+            raise exception.FileNotFound(file_path=file_path)

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

     else:

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

@@ -579,7 +578,7 @@ class FakeVim(object):
         """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"))

+            raise exception.NoFilesFound()

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

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

                 task_mdo = create_task(method, "success")

@@ -591,7 +590,7 @@ class FakeVim(object):
         """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"))

+            raise exception.NoFilesFound()

         _db_content["files"].append(ds_path)

 

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

diff --git a/nova/virt/vmwareapi/vmops.py b/nova/virt/vmwareapi/vmops.py
index b700c438f..c3e79a92f 100644
--- a/nova/virt/vmwareapi/vmops.py
+++ b/nova/virt/vmwareapi/vmops.py
@@ -100,8 +100,7 @@ class VMWareVMOps(object):
         """

         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)

+            raise exception.InstanceExists(name=instance.name)

 

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

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

@@ -116,8 +115,7 @@ class VMWareVMOps(object):
                 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)

+                raise exception.NetworkNotFoundForBridge(bridge=net_name)

 

         _check_if_network_bridge_exists()

 

@@ -337,8 +335,7 @@ class VMWareVMOps(object):
         """

         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)

+            raise exception.InstanceNotFound(instance_id=instance.id)

 

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

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

@@ -388,8 +385,7 @@ class VMWareVMOps(object):
                                     "VirtualMachine",

                                     "datastore")

             if not ds_ref_ret:

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

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

+                raise exception.DatastoreNotFound()

             ds_ref = ds_ref_ret.ManagedObjectReference[0]

             ds_browser = vim_util.get_dynamic_property(

                                        self._session._get_vim(),

@@ -480,8 +476,7 @@ class VMWareVMOps(object):
         """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)

+            raise exception.InstanceNotFound(instance_id=instance.id)

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

                           "summary.guest.toolsRunningStatus"]

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

@@ -605,8 +600,7 @@ class VMWareVMOps(object):
         """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)

+            raise exception.InstanceNotFound(instance_id=instance.id)

 

         pwr_state = self._session._call_method(vim_util,

                     "get_dynamic_property", vm_ref,

@@ -630,8 +624,7 @@ class VMWareVMOps(object):
         """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)

+            raise exception.InstanceNotFound(instance_id=instance.id)

 

         pwr_state = self._session._call_method(vim_util,

                                      "get_dynamic_property", vm_ref,

@@ -651,8 +644,7 @@ class VMWareVMOps(object):
         """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)

+            raise exception.InstanceNotFound(instance_id=instance_name)

 

         lst_properties = ["summary.config.numCpu",

                     "summary.config.memorySizeMB",

@@ -688,8 +680,7 @@ class VMWareVMOps(object):
         """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)

+            raise exception.InstanceNotFound(instance_id=instance.id)

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

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

                                          self._session._host_ip,

@@ -717,8 +708,7 @@ class VMWareVMOps(object):
         """

         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)

+            raise exception.InstanceNotFound(instance_id=instance.id)

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

                                             instance['id'])

         mac_addr = instance.mac_address

diff --git a/nova/virt/xenapi/vm_utils.py b/nova/virt/xenapi/vm_utils.py
index 1927500ad..c8f342aa8 100644
--- a/nova/virt/xenapi/vm_utils.py
+++ b/nova/virt/xenapi/vm_utils.py
@@ -506,9 +506,7 @@ class VMHelper(HelperBase):
             try:
                 return glance_disk_format2nova_type[disk_format]
             except KeyError:
-                raise exception.NotFound(
-                    _("Unrecognized disk_format '%(disk_format)s'")
-                    % locals())
+                raise exception.InvalidDiskFormat(disk_format=disk_format)
 
         def determine_from_instance():
             if instance.kernel_id:
@@ -643,8 +641,7 @@ class VMHelper(HelperBase):
         if n == 0:
             return None
         elif n > 1:
-            raise exception.Duplicate(_('duplicate name found: %s') %
-                                        name_label)
+            raise exception.InstanceExists(name=name_label)
         else:
             return vm_refs[0]
 
@@ -853,7 +850,7 @@ def safe_find_sr(session):
     """
     sr_ref = find_sr(session)
     if sr_ref is None:
-        raise exception.NotFound(_('Cannot find SR to read/write VDI'))
+        raise exception.StorageRepositoryNotFound()
     return sr_ref
 
 
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 8b6a35f74..30f31517d 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -127,8 +127,7 @@ class VMOps(object):
         instance_name = instance.name
         vm_ref = VMHelper.lookup(self._session, instance_name)
         if vm_ref is not None:
-            raise exception.Duplicate(_('Attempted to create'
-                    ' non-unique name %s') % instance_name)
+            raise exception.InstanceExists(name=instance_name)
 
         #ensure enough free memory is available
         if not VMHelper.ensure_free_mem(self._session, instance):
@@ -211,8 +210,6 @@ class VMOps(object):
         def _wait_for_boot():
             try:
                 state = self.get_info(instance_name)['state']
-                db.instance_set_state(context.get_admin_context(),
-                                      instance['id'], state)
                 if state == power_state.RUNNING:
                     LOG.debug(_('Instance %s: booted'), instance_name)
                     timer.stop()
@@ -220,11 +217,7 @@ class VMOps(object):
                     return True
             except Exception, exc:
                 LOG.warn(exc)
-                LOG.exception(_('instance %s: failed to boot'),
-                              instance_name)
-                db.instance_set_state(context.get_admin_context(),
-                                      instance['id'],
-                                      power_state.SHUTDOWN)
+                LOG.exception(_('Instance %s: failed to boot'), instance_name)
                 timer.stop()
                 return False
 
@@ -260,8 +253,7 @@ class VMOps(object):
             instance_name = instance_or_vm.name
         vm_ref = VMHelper.lookup(self._session, instance_name)
         if vm_ref is None:
-            raise exception.NotFound(
-                            _('Instance not present %s') % instance_name)
+            raise exception.InstanceNotFound(instance_id=instance_obj.id)
         return vm_ref
 
     def _acquire_bootlock(self, vm):
@@ -578,9 +570,8 @@ class VMOps(object):
 
         if not (instance.kernel_id and instance.ramdisk_id):
             # 2. We only have kernel xor ramdisk
-            raise exception.NotFound(
-                _("Instance %(instance_id)s has a kernel or ramdisk but not "
-                  "both" % locals()))
+            raise exception.InstanceUnacceptable(instance_id=instance_id,
+               reason=_("instance has a kernel or ramdisk but not both"))
 
         # 3. We have both kernel and ramdisk
         (kernel, ramdisk) = VMHelper.lookup_kernel_ramdisk(self._session,
@@ -721,8 +712,7 @@ class VMOps(object):
                                         "%s-rescue" % instance.name)
 
         if not rescue_vm_ref:
-            raise exception.NotFound(_(
-                "Instance is not in Rescue Mode: %s" % instance.name))
+            raise exception.InstanceNotInRescueMode(instance_id=instance.id)
 
         original_vm_ref = VMHelper.lookup(self._session, instance.name)
         instance._rescue = False
diff --git a/nova/virt/xenapi/volumeops.py b/nova/virt/xenapi/volumeops.py
index 757ecf5ad..afcb8cf47 100644
--- a/nova/virt/xenapi/volumeops.py
+++ b/nova/virt/xenapi/volumeops.py
@@ -45,8 +45,7 @@ class VolumeOps(object):
         # Before we start, check that the VM exists
         vm_ref = VMHelper.lookup(self._session, instance_name)
         if vm_ref is None:
-            raise exception.NotFound(_('Instance %s not found')
-                                      % instance_name)
+            raise exception.InstanceNotFound(instance_id=instance_name)
         # NOTE: No Resource Pool concept so far
         LOG.debug(_("Attach_volume: %(instance_name)s, %(device_path)s,"
                 " %(mountpoint)s") % locals())
@@ -98,8 +97,7 @@ class VolumeOps(object):
         # Before we start, check that the VM exists
         vm_ref = VMHelper.lookup(self._session, instance_name)
         if vm_ref is None:
-            raise exception.NotFound(_('Instance %s not found')
-                                     % instance_name)
+            raise exception.InstanceNotFound(instance_id=instance_name)
         # Detach VBD from VM
         LOG.debug(_("Detach_volume: %(instance_name)s, %(mountpoint)s")
                 % locals())