130 lines
5.0 KiB
Python
130 lines
5.0 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright (C) 2012 Yahoo! Inc. All Rights Reserved.
|
|
#
|
|
# 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.
|
|
|
|
import contextlib
|
|
import logging
|
|
|
|
from taskflow.engines.action_engine import base_action as base
|
|
from taskflow.openstack.common import excutils
|
|
from taskflow import states
|
|
from taskflow.utils import misc
|
|
|
|
LOG = logging.getLogger(__name__)
|
|
|
|
RESET_TASK_STATES = (states.PENDING,)
|
|
SAVE_RESULT_STATES = (states.SUCCESS, states.FAILURE)
|
|
ALREADY_FINISHED_STATES = (states.SUCCESS,)
|
|
NEVER_RAN_STATES = (states.PENDING,)
|
|
|
|
|
|
@contextlib.contextmanager
|
|
def _autobind(task, bind_name, bind_func, **kwargs):
|
|
try:
|
|
task.bind(bind_name, bind_func, **kwargs)
|
|
yield task
|
|
finally:
|
|
task.unbind(bind_name, bind_func)
|
|
|
|
|
|
class TaskAction(base.Action):
|
|
|
|
def __init__(self, task, task_id):
|
|
self._task = task
|
|
self._id = task_id
|
|
|
|
@property
|
|
def name(self):
|
|
return self._task.name
|
|
|
|
@property
|
|
def uuid(self):
|
|
return self._id
|
|
|
|
def _change_state(self, engine, state,
|
|
result=None, progress=None, force=False):
|
|
"""Update result and change state."""
|
|
old_state = engine.storage.get_task_state(self.uuid)
|
|
state_check = states.check_task_transition(old_state, state)
|
|
if not force and not state_check:
|
|
# NOTE(harlowja): if we are forcing this state change, we don't
|
|
# care if the state transition should be ignored, if it's not being
|
|
# forced then we just ignore this state change.
|
|
return
|
|
if state in RESET_TASK_STATES:
|
|
engine.storage.reset(self.uuid)
|
|
if state in SAVE_RESULT_STATES:
|
|
engine.storage.save(self.uuid, result, state)
|
|
else:
|
|
engine.storage.set_task_state(self.uuid, state)
|
|
if progress is not None:
|
|
engine.storage.set_task_progress(self.uuid, progress)
|
|
engine._on_task_state_change(self, state, result=result)
|
|
|
|
def _on_update_progress(self, task, event_data, progress, **kwargs):
|
|
"""Update task progress value that stored in engine."""
|
|
try:
|
|
engine = event_data['engine']
|
|
engine.storage.set_task_progress(self.uuid, progress, **kwargs)
|
|
except Exception:
|
|
# Update progress callbacks should never fail, so capture and log
|
|
# the emitted exception instead of raising it.
|
|
LOG.exception("Failed setting task progress for %s (%s) to %0.3f",
|
|
task, self.uuid, progress)
|
|
|
|
def _force_state(self, engine, state, progress, result=None):
|
|
self._change_state(engine, state,
|
|
result=result, progress=progress, force=True)
|
|
self._task.update_progress(progress)
|
|
|
|
def execute(self, engine):
|
|
if engine.storage.get_task_state(self.uuid) in ALREADY_FINISHED_STATES:
|
|
# Skip tasks that already finished.
|
|
return
|
|
self._force_state(engine, states.RUNNING, 0.0)
|
|
with _autobind(self._task,
|
|
'update_progress', self._on_update_progress,
|
|
engine=engine):
|
|
try:
|
|
kwargs = engine.storage.fetch_mapped_args(self._task.rebind)
|
|
result = self._task.execute(**kwargs)
|
|
except Exception:
|
|
failure = misc.Failure()
|
|
self._change_state(engine, states.FAILURE, result=failure)
|
|
failure.reraise()
|
|
self._force_state(engine, states.SUCCESS, 1.0, result=result)
|
|
|
|
def revert(self, engine):
|
|
if engine.storage.get_task_state(self.uuid) in NEVER_RAN_STATES:
|
|
# NOTE(imelnikov): in all the other states, the task
|
|
# execution was at least attempted, so we should give
|
|
# task a chance for cleanup
|
|
return
|
|
self._force_state(engine, states.REVERTING, 0.0)
|
|
with _autobind(self._task,
|
|
'update_progress', self._on_update_progress,
|
|
engine=engine):
|
|
kwargs = engine.storage.fetch_mapped_args(self._task.rebind)
|
|
try:
|
|
self._task.revert(result=engine.storage.get(self._id),
|
|
**kwargs)
|
|
except Exception:
|
|
with excutils.save_and_reraise_exception():
|
|
self._change_state(engine, states.FAILURE)
|
|
self._force_state(engine, states.REVERTED, 1.0)
|
|
self._force_state(engine, states.PENDING, 0.0)
|