From ad7a0eb293275a04ddc236604efcf4a093ab67eb Mon Sep 17 00:00:00 2001 From: Matt Riedemann Date: Thu, 29 May 2014 07:33:16 -0700 Subject: [PATCH] Sync periodic_task from oslo-incubator This is more or less to get commit c63fd5a from oslo into the core projects which have several periodic tasks. Neutron has periodic tasks for L3, load balancing and metering agents to sync up state with the server and most don't have specific spacing values set which can lead to non-deterministic spacing of when the tasks run. Note that this does not include the gettextutils and log dependencies since there are not functional changes in those modules needed for the periodic_task changes synced in *and* more importantly, the changes to gettextutils and log require pervasive changes to neutron which should happen when neutron integrates with the oslo-i18n library for blueprint i18n--messages. Further note that this does not include jsonutils due to some issues introduced with a change for python 2.6 that impacts how strings are encoded with simplejson. The details for that issue are in bug 1314129. The jsonutils changes are not related to the periodic_task changes being synced in so the dependency is not functionally required. The LbaasAgentManager extends PeriodicTasks but wasn't calling the parent class init function, which was causing failures since commit 47c9d60 changed PeriodicTasks to init _periodic_last_run, so also fixed that here. Changes: c63fd5a Make unspecified periodic spaced tasks run on default interval f0dd798 Remove rendundant parentheses of cfg help strings fcf517d Update oslo log messages with translation domains 051b9f3 Refactor unnecessary arithmetic ops in periodic_task 674cdaf Refactor if logic in periodic_task b6b82c5 Use timestamp in periodic tasks 47c9d60 Don't share periodic_task instance data in a class attr 8b2b0b7 Use hacking import_exceptions for gettextutils._ Related-Bug: #1319232 Change-Id: Ib23e33326129be0dd952efde263f381d5aa2457f --- neutron/openstack/common/periodic_task.py | 57 +++++++++---------- .../loadbalancer/agent/agent_manager.py | 1 + 2 files changed, 27 insertions(+), 31 deletions(-) diff --git a/neutron/openstack/common/periodic_task.py b/neutron/openstack/common/periodic_task.py index cf2985e13a..1ebdc1af6f 100644 --- a/neutron/openstack/common/periodic_task.py +++ b/neutron/openstack/common/periodic_task.py @@ -11,22 +11,20 @@ # License for the specific language governing permissions and limitations # under the License. -import datetime import time from oslo.config import cfg import six -from neutron.openstack.common.gettextutils import _ +from neutron.openstack.common.gettextutils import _, _LE, _LI from neutron.openstack.common import log as logging -from neutron.openstack.common import timeutils periodic_opts = [ cfg.BoolOpt('run_external_periodic_tasks', default=True, - help=('Some periodic tasks can be run in a separate process. ' - 'Should we run them here?')), + help='Some periodic tasks can be run in a separate process. ' + 'Should we run them here?'), ] CONF = cfg.CONF @@ -46,8 +44,8 @@ def periodic_task(*args, **kwargs): This decorator can be used in two ways: - 1. Without arguments '@periodic_task', this will be run on every cycle - of the periodic scheduler. + 1. Without arguments '@periodic_task', this will be run on the default + interval of 60 seconds. 2. With arguments: @periodic_task(spacing=N [, run_immediately=[True|False]]) @@ -78,7 +76,7 @@ def periodic_task(*args, **kwargs): if f._periodic_immediate: f._periodic_last_run = None else: - f._periodic_last_run = timeutils.utcnow() + f._periodic_last_run = time.time() return f # NOTE(sirp): The `if` is necessary to allow the decorator to be used with @@ -113,11 +111,6 @@ class _PeriodicTasksMeta(type): except AttributeError: cls._periodic_tasks = [] - try: - cls._periodic_last_run = cls._periodic_last_run.copy() - except AttributeError: - cls._periodic_last_run = {} - try: cls._periodic_spacing = cls._periodic_spacing.copy() except AttributeError: @@ -129,28 +122,33 @@ class _PeriodicTasksMeta(type): name = task.__name__ if task._periodic_spacing < 0: - LOG.info(_('Skipping periodic task %(task)s because ' - 'its interval is negative'), + LOG.info(_LI('Skipping periodic task %(task)s because ' + 'its interval is negative'), {'task': name}) continue if not task._periodic_enabled: - LOG.info(_('Skipping periodic task %(task)s because ' - 'it is disabled'), + LOG.info(_LI('Skipping periodic task %(task)s because ' + 'it is disabled'), {'task': name}) continue # A periodic spacing of zero indicates that this task should - # be run every pass + # be run on the default interval to avoid running too + # frequently. if task._periodic_spacing == 0: - task._periodic_spacing = None + task._periodic_spacing = DEFAULT_INTERVAL cls._periodic_tasks.append((name, task)) cls._periodic_spacing[name] = task._periodic_spacing - cls._periodic_last_run[name] = task._periodic_last_run @six.add_metaclass(_PeriodicTasksMeta) class PeriodicTasks(object): + def __init__(self): + super(PeriodicTasks, self).__init__() + self._periodic_last_run = {} + for name, task in self._periodic_tasks: + self._periodic_last_run[name] = task._periodic_last_run def run_periodic_tasks(self, context, raise_on_error=False): """Tasks to be run at a periodic interval.""" @@ -158,30 +156,27 @@ class PeriodicTasks(object): for task_name, task in self._periodic_tasks: full_task_name = '.'.join([self.__class__.__name__, task_name]) - now = timeutils.utcnow() spacing = self._periodic_spacing[task_name] last_run = self._periodic_last_run[task_name] # If a periodic task is _nearly_ due, then we'll run it early - if spacing is not None and last_run is not None: - due = last_run + datetime.timedelta(seconds=spacing) - if not timeutils.is_soon(due, 0.2): - idle_for = min(idle_for, timeutils.delta_seconds(now, due)) + idle_for = min(idle_for, spacing) + if last_run is not None: + delta = last_run + spacing - time.time() + if delta > 0.2: + idle_for = min(idle_for, delta) continue - if spacing is not None: - idle_for = min(idle_for, spacing) - - LOG.debug(_("Running periodic task %(full_task_name)s"), + LOG.debug("Running periodic task %(full_task_name)s", {"full_task_name": full_task_name}) - self._periodic_last_run[task_name] = timeutils.utcnow() + self._periodic_last_run[task_name] = time.time() try: task(self, context) except Exception as e: if raise_on_error: raise - LOG.exception(_("Error during %(full_task_name)s: %(e)s"), + LOG.exception(_LE("Error during %(full_task_name)s: %(e)s"), {"full_task_name": full_task_name, "e": e}) time.sleep(0) diff --git a/neutron/services/loadbalancer/agent/agent_manager.py b/neutron/services/loadbalancer/agent/agent_manager.py index e94978e900..0e315554a6 100644 --- a/neutron/services/loadbalancer/agent/agent_manager.py +++ b/neutron/services/loadbalancer/agent/agent_manager.py @@ -58,6 +58,7 @@ class LbaasAgentManager(periodic_task.PeriodicTasks): # object individually; def __init__(self, conf): + super(LbaasAgentManager, self).__init__() self.conf = conf self.context = context.get_admin_context_without_session() self.plugin_rpc = agent_api.LbaasAgentApi(