Merging trunk

2 files changed, 80 insertions, 48 deletions

diff --git a/nova/compute/api.py b/nova/compute/api.py
index efd6d166b..59a392e7a 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -496,6 +496,16 @@ class API(base.Base):
                      {"method": "refresh_security_group_members",
                       "args": {"security_group_id": group_id}})
 
+    def trigger_provider_fw_rules_refresh(self, context):
+        """Called when a rule is added to or removed from a security_group"""
+
+        hosts = [x['host'] for (x, idx)
+                           in db.service_get_all_compute_sorted(context)]
+        for host in hosts:
+            rpc.cast(context,
+                     self.db.queue_get_for(context, FLAGS.compute_topic, host),
+                     {'method': 'refresh_provider_fw_rules', 'args': {}})
+
     def update(self, context, instance_id, **kwargs):
         """Updates the instance in the datastore.
 
@@ -701,31 +711,36 @@ class API(base.Base):
         raise exception.Error(_("Unable to find host for Instance %s")
                                 % instance_id)
 
-    def backup(self, context, instance_id, name, backup_type, rotation):
+    def backup(self, context, instance_id, name, backup_type, rotation,
+               extra_properties=None):
         """Backup the given instance
 
         :param instance_id: nova.db.sqlalchemy.models.Instance.Id
         :param name: name of the backup or snapshot
-        name = backup_type  # daily backups are called 'daily'
+            name = backup_type  # daily backups are called 'daily'
         :param rotation: int representing how many backups to keep around;
             None if rotation shouldn't be used (as in the case of snapshots)
+        :param extra_properties: dict of extra image properties to include
         """
         recv_meta = self._create_image(context, instance_id, name, 'backup',
-                            backup_type=backup_type, rotation=rotation)
+                            backup_type=backup_type, rotation=rotation,
+                            extra_properties=extra_properties)
         return recv_meta
 
-    def snapshot(self, context, instance_id, name):
+    def snapshot(self, context, instance_id, name, extra_properties=None):
         """Snapshot the given instance.
 
         :param instance_id: nova.db.sqlalchemy.models.Instance.Id
         :param name: name of the backup or snapshot
+        :param extra_properties: dict of extra image properties to include
 
         :returns: A dict containing image metadata
         """
-        return self._create_image(context, instance_id, name, 'snapshot')
+        return self._create_image(context, instance_id, name, 'snapshot',
+                                  extra_properties=extra_properties)
 
     def _create_image(self, context, instance_id, name, image_type,
-                      backup_type=None, rotation=None):
+                      backup_type=None, rotation=None, extra_properties=None):
         """Create snapshot or backup for an instance on this host.
 
         :param context: security context
@@ -735,6 +750,8 @@ class API(base.Base):
         :param backup_type: daily | weekly
         :param rotation: int representing how many backups to keep around;
             None if rotation shouldn't be used (as in the case of snapshots)
+        :param extra_properties: dict of extra image properties to include
+
         """
         instance = db.api.instance_get(context, instance_id)
         properties = {'instance_uuid': instance['uuid'],
@@ -742,6 +759,7 @@ class API(base.Base):
                       'image_state': 'creating',
                       'image_type': image_type,
                       'backup_type': backup_type}
+        properties.update(extra_properties or {})
         sent_meta = {'name': name, 'is_public': False,
                      'status': 'creating', 'properties': properties}
         recv_meta = self.image_service.create(context, sent_meta)
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 8708768fb..9d71ff922 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -217,6 +217,11 @@ class ComputeManager(manager.SchedulerDependentManager):
         """
         return self.driver.refresh_security_group_members(security_group_id)
 
+    @exception.wrap_exception
+    def refresh_provider_fw_rules(self, context, **_kwargs):
+        """This call passes straight through to the virtualization driver."""
+        return self.driver.refresh_provider_fw_rules()
+
     def _setup_block_device_mapping(self, context, instance_id):
         """setup volumes for block device mapping"""
         self.db.instance_set_state(context,
@@ -293,50 +298,59 @@ class ComputeManager(manager.SchedulerDependentManager):
                                    'networking')
 
         is_vpn = instance_ref['image_ref'] == str(FLAGS.vpn_image_id)
-        # NOTE(vish): This could be a cast because we don't do anything
-        #             with the address currently, but I'm leaving it as
-        #             a call to ensure that network setup completes.  We
-        #             will eventually also need to save the address here.
-        if not FLAGS.stub_network:
-            address = rpc.call(context,
-                               self.get_network_topic(context),
-                               {"method": "allocate_fixed_ip",
-                                "args": {"instance_id": instance_id,
-                                         "vpn": is_vpn}})
-
-            self.network_manager.setup_compute_network(context,
-                                                       instance_id)
-
-        block_device_mapping = self._setup_block_device_mapping(context,
-                                                                instance_id)
-
-        # TODO(vish) check to make sure the availability zone matches
-        self._update_state(context, instance_id, power_state.BUILDING)
-
         try:
-            self.driver.spawn(instance_ref,
-                              block_device_mapping=block_device_mapping)
-        except Exception as ex:  # pylint: disable=W0702
-            msg = _("Instance '%(instance_id)s' failed to spawn. Is "
-                    "virtualization enabled in the BIOS? Details: "
-                    "%(ex)s") % locals()
-            LOG.exception(msg)
-
-        if not FLAGS.stub_network and FLAGS.auto_assign_floating_ip:
-            public_ip = self.network_api.allocate_floating_ip(context)
-
-            self.db.floating_ip_set_auto_assigned(context, public_ip)
-            fixed_ip = self.db.fixed_ip_get_by_address(context, address)
-            floating_ip = self.db.floating_ip_get_by_address(context,
-                                                             public_ip)
-
-            self.network_api.associate_floating_ip(context,
-                                                   floating_ip,
-                                                   fixed_ip,
-                                                   affect_auto_assigned=True)
+            # NOTE(vish): This could be a cast because we don't do anything
+            #             with the address currently, but I'm leaving it as
+            #             a call to ensure that network setup completes.  We
+            #             will eventually also need to save the address here.
+            if not FLAGS.stub_network:
+                address = rpc.call(context,
+                                   self.get_network_topic(context),
+                                   {"method": "allocate_fixed_ip",
+                                    "args": {"instance_id": instance_id,
+                                             "vpn": is_vpn}})
 
-        self._update_launched_at(context, instance_id)
-        self._update_state(context, instance_id)
+                self.network_manager.setup_compute_network(context,
+                                                           instance_id)
+
+            block_device_mapping = self._setup_block_device_mapping(
+                context,
+                instance_id)
+
+            # TODO(vish) check to make sure the availability zone matches
+            self._update_state(context, instance_id, power_state.BUILDING)
+
+            try:
+                self.driver.spawn(instance_ref,
+                                  block_device_mapping=block_device_mapping)
+            except Exception as ex:  # pylint: disable=W0702
+                msg = _("Instance '%(instance_id)s' failed to spawn. Is "
+                        "virtualization enabled in the BIOS? Details: "
+                        "%(ex)s") % locals()
+                LOG.exception(msg)
+
+            if not FLAGS.stub_network and FLAGS.auto_assign_floating_ip:
+                public_ip = self.network_api.allocate_floating_ip(context)
+
+                self.db.floating_ip_set_auto_assigned(context, public_ip)
+                fixed_ip = self.db.fixed_ip_get_by_address(context, address)
+                floating_ip = self.db.floating_ip_get_by_address(context,
+                                                                 public_ip)
+
+                self.network_api.associate_floating_ip(
+                    context,
+                    floating_ip,
+                    fixed_ip,
+                    affect_auto_assigned=True)
+
+            self._update_launched_at(context, instance_id)
+            self._update_state(context, instance_id)
+        except exception.InstanceNotFound:
+            # FIXME(wwolf): We are just ignoring InstanceNotFound
+            # exceptions here in case the instance was immediately
+            # deleted before it actually got created.  This should
+            # be fixed once we have no-db-messaging
+            pass
 
     @exception.wrap_exception
     def run_instance(self, context, instance_id, **kwargs):