Merge "Add basic infrastructure for compute driver async events"

2 files changed, 119 insertions, 0 deletions

diff --git a/nova/virt/driver.py b/nova/virt/driver.py
index 13b8bead8..c0979c9d1 100755
--- a/nova/virt/driver.py
+++ b/nova/virt/driver.py
@@ -28,6 +28,7 @@ from nova.openstack.common import cfg
 from nova.openstack.common import importutils
 from nova.openstack.common import log as logging
 from nova import utils
+from nova.virt import event as virtevent
 
 driver_opts = [
     cfg.StrOpt('compute_driver',
@@ -130,6 +131,7 @@ class ComputeDriver(object):
 
     def __init__(self, virtapi):
         self.virtapi = virtapi
+        self._compute_event_callback = None
 
     def init_host(self, host):
         """Initialize anything that is necessary for the driver to function,
@@ -863,6 +865,38 @@ class ComputeDriver(object):
         """
         return False
 
+    def register_event_listener(self, callback):
+        """Register a callback to receive events.
+
+        Register a callback to receive asynchronous event
+        notifications from hypervisors. The callback will
+        be invoked with a single parameter, which will be
+        an instance of the nova.virt.event.Event class."""
+
+        self._compute_event_callback = callback
+
+    def emit_event(self, event):
+        """Dispatches an event to the compute manager.
+
+        Invokes the event callback registered by the
+        compute manager to dispatch the event. This
+        must only be invoked from a green thread."""
+
+        if not self._compute_event_callback:
+            LOG.debug("Discarding event %s" % str(event))
+            return
+
+        if not isinstance(event, virtevent.Event):
+            raise ValueError(
+                _("Event must be an instance of nova.virt.event.Event"))
+
+        try:
+            LOG.debug("Emitting event %s" % str(event))
+            self._compute_event_callback(event)
+        except Exception, ex:
+            LOG.error(_("Exception dispatching event %(event)s: %(ex)s")
+                        % locals())
+
 
 def load_compute_driver(virtapi, compute_driver=None):
     """Load a compute driver module.
diff --git a/nova/virt/event.py b/nova/virt/event.py
new file mode 100644
index 000000000..684986f8a
--- /dev/null
+++ b/nova/virt/event.py
@@ -0,0 +1,85 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2013 Red Hat, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""
+Asynchronous event notifications from virtualization drivers.
+
+This module defines a set of classes representing data for
+various asynchronous events that can occurr in a virtualization
+driver.
+"""
+
+import time
+
+EVENT_LIFECYCLE_STARTED = 0
+EVENT_LIFECYCLE_STOPPED = 1
+EVENT_LIFECYCLE_PAUSED = 2
+EVENT_LIFECYCLE_RESUMED = 3
+
+
+class Event(object):
+    """Base class for all events emitted by a hypervisor.
+
+    All events emitted by a virtualization driver are
+    subclasses of this base object. The only generic
+    information recorded in the base class is a timestamp
+    indicating when the event first occurred. The timestamp
+    is recorded as fractional seconds since the UNIX epoch.
+    """
+
+    def __init__(self, timestamp=None):
+        if timestamp is None:
+            self.timestamp = time.time()
+        else:
+            self.timestamp = timestamp
+
+    def get_timestamp(self):
+        return self.timestamp
+
+
+class InstanceEvent(Event):
+    """Base class for all instance events.
+
+    All events emitted by a virtualization driver which
+    are associated with a virtual domain instance are
+    subclasses of this base object. This object records
+    the UUID associated with the instance."""
+
+    def __init__(self, uuid, timestamp=None):
+        super(InstanceEvent, self).__init__(timestamp)
+
+        self.uuid = uuid
+
+    def get_instance_uuid(self):
+        return self.uuid
+
+
+class LifecycleEvent(InstanceEvent):
+    """Class for instance lifecycle state change events.
+
+    When a virtual domain instance lifecycle state changes,
+    events of this class are emitted. The EVENT_LIFECYCLE_XX
+    constants defined why lifecycle change occurred. This
+    event allows detection of an instance starting/stopping
+    without need for polling"""
+
+    def __init__(self, uuid, transition, timestamp=None):
+        super(LifecycleEvent, self).__init__(uuid, timestamp)
+
+        self.transition = transition
+
+    def get_transition(self):
+        return self.transition