Copy recent changes in periodic tasks from nova.

The nova periodic task code has moved on. Bring oslo inline with
the new code. The next step after this is to update Quantum (the
only user of this code I can find) to the new interface, and then
move nova across to using this code.

Change-Id: I3f041ca9a6ba9f0e5be4b29198d16454c9797fef

1 files changed, 178 insertions, 1 deletions

diff --git a/tests/unit/test_periodic.py b/tests/unit/test_periodic.py
index c39d085..1fb1574 100644
--- a/tests/unit/test_periodic.py
+++ b/tests/unit/test_periodic.py
@@ -19,8 +19,13 @@
 """
 Unit Tests for periodic_task decorator and PeriodicTasks class.
 """
+
+import datetime
+
 from openstack.common import periodic_task
+from openstack.common import timeutils
 from tests import utils
+from testtools import matchers
 
 
 class AService(periodic_task.PeriodicTasks):
@@ -37,7 +42,7 @@ class AService(periodic_task.PeriodicTasks):
         self.called['urg'] = True
         raise Exception('urg')
 
-    @periodic_task.periodic_task(ticks_between_runs=1)
+    @periodic_task.periodic_task(spacing=10)
     def doit_with_kwargs_odd(self, context):
         self.called['ticks'] = True
 
@@ -64,3 +69,175 @@ class PeriodicTasksTestCase(utils.BaseTestCase):
         self.assertRaises(Exception,
                           serv.run_periodic_tasks,
                           None, raise_on_error=True)
+
+
+class ManagerMetaTestCase(utils.BaseTestCase):
+    """Tests for the meta class which manages the creation of periodic tasks.
+    """
+
+    def test_meta(self):
+        class Manager(periodic_task.PeriodicTasks):
+            __metaclass__ = periodic_task._PeriodicTasksMeta
+
+            @periodic_task.periodic_task
+            def foo(self):
+                return 'foo'
+
+            @periodic_task.periodic_task(spacing=4)
+            def bar(self):
+                return 'bar'
+
+            @periodic_task.periodic_task(enabled=False)
+            def baz(self):
+                return 'baz'
+
+        m = Manager()
+        self.assertThat(m._periodic_tasks, matchers.HasLength(2))
+        self.assertEqual(None, m._periodic_spacing['foo'])
+        self.assertEqual(4, m._periodic_spacing['bar'])
+        self.assertThat(
+            m._periodic_spacing, matchers.Not(matchers.Contains('baz')))
+
+
+class ManagerTestCase(utils.BaseTestCase):
+    """Tests the periodic tasks portion of the manager class."""
+
+    def test_periodic_tasks_with_idle(self):
+        class Manager(periodic_task.PeriodicTasks):
+            __metaclass__ = periodic_task._PeriodicTasksMeta
+
+            @periodic_task.periodic_task(spacing=200)
+            def bar(self):
+                return 'bar'
+
+        m = Manager()
+        self.assertThat(m._periodic_tasks, matchers.HasLength(1))
+        self.assertEqual(200, m._periodic_spacing['bar'])
+
+        # Now a single pass of the periodic tasks
+        idle = m.run_periodic_tasks(None)
+        self.assertAlmostEqual(60, idle, 1)
+
+    def test_periodic_tasks_constant(self):
+        class Manager(periodic_task.PeriodicTasks):
+            __metaclass__ = periodic_task._PeriodicTasksMeta
+
+            @periodic_task.periodic_task(spacing=0)
+            def bar(self):
+                return 'bar'
+
+        m = Manager()
+        idle = m.run_periodic_tasks(None)
+        self.assertAlmostEqual(60, idle, 1)
+
+    def test_periodic_tasks_idle_calculation(self):
+        fake_time = datetime.datetime(3000, 1, 1)
+        timeutils.set_time_override(fake_time)
+
+        class Manager(periodic_task.PeriodicTasks):
+            __metaclass__ = periodic_task._PeriodicTasksMeta
+
+            @periodic_task.periodic_task(spacing=10)
+            def bar(self, context):
+                return 'bar'
+
+        m = Manager()
+
+        # Ensure initial values are correct
+        self.assertEqual(1, len(m._periodic_tasks))
+        task_name, task = m._periodic_tasks[0]
+
+        # Test task values
+        self.assertEqual('bar', task_name)
+        self.assertEqual(10, task._periodic_spacing)
+        self.assertEqual(True, task._periodic_enabled)
+        self.assertEqual(False, task._periodic_external_ok)
+        self.assertEqual(False, task._periodic_immediate)
+        self.assertNotEqual(None, task._periodic_last_run)
+
+        # Test the manager's representation of those values
+        self.assertEqual(10, m._periodic_spacing[task_name])
+        self.assertNotEqual(None, m._periodic_last_run[task_name])
+
+        timeutils.advance_time_delta(datetime.timedelta(seconds=5))
+        m.run_periodic_tasks(None)
+
+        timeutils.advance_time_delta(datetime.timedelta(seconds=5))
+        idle = m.run_periodic_tasks(None)
+        self.assertAlmostEqual(10, idle, 1)
+
+    def test_periodic_tasks_immediate_runs_now(self):
+        fake_time = datetime.datetime(3000, 1, 1)
+        timeutils.set_time_override(fake_time)
+
+        class Manager(periodic_task.PeriodicTasks):
+            __metaclass__ = periodic_task._PeriodicTasksMeta
+
+            @periodic_task.periodic_task(spacing=10, run_immediately=True)
+            def bar(self, context):
+                return 'bar'
+
+        m = Manager()
+
+        # Ensure initial values are correct
+        self.assertEqual(1, len(m._periodic_tasks))
+        task_name, task = m._periodic_tasks[0]
+
+        # Test task values
+        self.assertEqual('bar', task_name)
+        self.assertEqual(10, task._periodic_spacing)
+        self.assertEqual(True, task._periodic_enabled)
+        self.assertEqual(False, task._periodic_external_ok)
+        self.assertEqual(True, task._periodic_immediate)
+        self.assertEqual(None, task._periodic_last_run)
+
+        # Test the manager's representation of those values
+        self.assertEqual(10, m._periodic_spacing[task_name])
+        self.assertEqual(None, m._periodic_last_run[task_name])
+
+        idle = m.run_periodic_tasks(None)
+        self.assertEqual(datetime.datetime(3000, 1, 1, 0, 0),
+                         m._periodic_last_run[task_name])
+        self.assertAlmostEqual(10, idle, 1)
+
+        timeutils.advance_time_delta(datetime.timedelta(seconds=5))
+        idle = m.run_periodic_tasks(None)
+        self.assertAlmostEqual(5, idle, 1)
+
+    def test_periodic_tasks_disabled(self):
+        class Manager(periodic_task.PeriodicTasks):
+            __metaclass__ = periodic_task._PeriodicTasksMeta
+
+            @periodic_task.periodic_task(spacing=-1)
+            def bar(self):
+                return 'bar'
+
+        m = Manager()
+        idle = m.run_periodic_tasks(None)
+        self.assertAlmostEqual(60, idle, 1)
+
+    def test_external_running_here(self):
+        self.config(run_external_periodic_tasks=True)
+
+        class Manager(periodic_task.PeriodicTasks):
+            __metaclass__ = periodic_task._PeriodicTasksMeta
+
+            @periodic_task.periodic_task(spacing=200, external_process_ok=True)
+            def bar(self):
+                return 'bar'
+
+        m = Manager()
+        self.assertThat(m._periodic_tasks, matchers.HasLength(1))
+
+    def test_external_running_elsewhere(self):
+        self.config(run_external_periodic_tasks=False)
+
+        class Manager(periodic_task.PeriodicTasks):
+            __metaclass__ = periodic_task._PeriodicTasksMeta
+
+            @periodic_task.periodic_task(spacing=200, external_process_ok=True)
+            def bar(self):
+                return 'bar'
+
+        m = Manager()
+        self.assertEqual([], m._periodic_tasks)