c73c097560
Provides and requires properties are used to browse all required and provided values for the whole Flow. The same properties were added to the Task. Appropriate Task properties were renamed to rebind and save_as. Change-Id: I02eb02303a9701a13f1a54f06f20bbf9aebd1d04
198 lines
7.2 KiB
Python
198 lines
7.2 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# vim: tabstop=4 shiftwidth=4 softtabstop=4
|
|
|
|
# Copyright (C) 2013 Rackspace Hosting Inc. All Rights Reserved.
|
|
# Copyright (C) 2013 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 abc
|
|
|
|
from taskflow.utils import misc
|
|
from taskflow.utils import reflection
|
|
|
|
|
|
def _save_as_to_mapping(save_as):
|
|
"""Convert save_as to mapping name => index
|
|
|
|
Result should follow storage convention for mappings.
|
|
"""
|
|
# TODO(harlowja): we should probably document this behavior & convention
|
|
# outside of code so that its more easily understandable, since what a task
|
|
# returns is pretty crucial for other later operations.
|
|
if save_as is None:
|
|
return {}
|
|
if isinstance(save_as, basestring):
|
|
# NOTE(harlowja): this means that your task will only return one item
|
|
# instead of a dictionary-like object or a indexable object (like a
|
|
# list or tuple).
|
|
return {save_as: None}
|
|
elif isinstance(save_as, (tuple, list)):
|
|
# NOTE(harlowja): this means that your task will return a indexable
|
|
# object, like a list or tuple and the results can be mapped by index
|
|
# to that tuple/list that is returned for others to use.
|
|
return dict((key, num) for num, key in enumerate(save_as))
|
|
elif isinstance(save_as, set):
|
|
# NOTE(harlowja): in the case where a set is given we will not be
|
|
# able to determine the numeric ordering in a reliable way (since it is
|
|
# a unordered set) so the only way for us to easily map the result of
|
|
# the task will be via the key itself.
|
|
return dict((key, key) for key in save_as)
|
|
raise TypeError('Task provides parameter '
|
|
'should be str, set or tuple/list, not %r' % save_as)
|
|
|
|
|
|
def _build_rebind_dict(args, rebind_args):
|
|
if rebind_args is None:
|
|
return {}
|
|
elif isinstance(rebind_args, (list, tuple)):
|
|
rebind = dict(zip(args, rebind_args))
|
|
if len(args) < len(rebind_args):
|
|
rebind.update((a, a) for a in rebind_args[len(args):])
|
|
return rebind
|
|
elif isinstance(rebind_args, dict):
|
|
return rebind_args
|
|
else:
|
|
raise TypeError('Invalid rebind value: %s' % rebind_args)
|
|
|
|
|
|
def _check_args_mapping(task_name, rebind, args, accepts_kwargs):
|
|
args = set(args)
|
|
rebind = set(rebind.keys())
|
|
extra_args = rebind - args
|
|
missing_args = args - rebind
|
|
if not accepts_kwargs and extra_args:
|
|
raise ValueError('Extra arguments given to task %s: %s'
|
|
% (task_name, sorted(extra_args)))
|
|
if missing_args:
|
|
raise ValueError('Missing arguments for task %s: %s'
|
|
% (task_name, sorted(missing_args)))
|
|
|
|
|
|
def _build_arg_mapping(task_name, reqs, rebind_args, function, do_infer):
|
|
task_args = reflection.get_required_callable_args(function)
|
|
accepts_kwargs = reflection.accepts_kwargs(function)
|
|
result = {}
|
|
if reqs:
|
|
result.update((a, a) for a in reqs)
|
|
if do_infer:
|
|
result.update((a, a) for a in task_args)
|
|
result.update(_build_rebind_dict(task_args, rebind_args))
|
|
_check_args_mapping(task_name, result, task_args, accepts_kwargs)
|
|
return result
|
|
|
|
|
|
class BaseTask(object):
|
|
"""An abstraction that defines a potential piece of work that can be
|
|
applied and can be reverted to undo the work as a single unit.
|
|
"""
|
|
__metaclass__ = abc.ABCMeta
|
|
|
|
def __init__(self, name, provides=None):
|
|
self._name = name
|
|
# An *immutable* input 'resource' name mapping this task depends
|
|
# on existing before this task can be applied.
|
|
#
|
|
# Format is input_name:arg_name
|
|
self.rebind = {}
|
|
# An *immutable* output 'resource' name dict this task
|
|
# produces that other tasks may depend on this task providing.
|
|
#
|
|
# Format is output index:arg_name
|
|
self.save_as = _save_as_to_mapping(provides)
|
|
# This identifies the version of the task to be ran which
|
|
# can be useful in resuming older versions of tasks. Standard
|
|
# major, minor version semantics apply.
|
|
self.version = (1, 0)
|
|
|
|
@property
|
|
def name(self):
|
|
return self._name
|
|
|
|
def __str__(self):
|
|
return "%s==%s" % (self.name, misc.get_task_version(self))
|
|
|
|
@abc.abstractmethod
|
|
def execute(self, *args, **kwargs):
|
|
"""Activate a given task which will perform some operation and return.
|
|
|
|
This method can be used to apply some given context and given set
|
|
of args and kwargs to accomplish some goal. Note that the result
|
|
that is returned needs to be serializable so that it can be passed
|
|
back into this task if reverting is triggered.
|
|
"""
|
|
|
|
def revert(self, *args, **kwargs):
|
|
"""Revert this task using the given context, result that the apply
|
|
provided as well as any information which may have caused
|
|
said reversion.
|
|
"""
|
|
|
|
@property
|
|
def provides(self):
|
|
return set(self.save_as)
|
|
|
|
@property
|
|
def requires(self):
|
|
return set(self.rebind.values())
|
|
|
|
|
|
class Task(BaseTask):
|
|
"""Base class for user-defined tasks
|
|
|
|
Adds following features to Task:
|
|
- auto-generates name from type of self
|
|
- adds all execute argument names to task requirements
|
|
"""
|
|
|
|
def __init__(self, name=None, provides=None, requires=None,
|
|
auto_extract=True, rebind=None):
|
|
"""Initialize task instance"""
|
|
if name is None:
|
|
name = reflection.get_callable_name(self)
|
|
super(Task, self).__init__(name,
|
|
provides=provides)
|
|
self.rebind = _build_arg_mapping(self.name, requires, rebind,
|
|
self.execute, auto_extract)
|
|
|
|
|
|
class FunctorTask(BaseTask):
|
|
"""Adaptor to make task from a callable
|
|
|
|
Take any callable and make a task from it.
|
|
"""
|
|
|
|
def __init__(self, execute, name=None, provides=None,
|
|
requires=None, auto_extract=True, rebind=None, revert=None,
|
|
version=None):
|
|
"""Initialize FunctorTask instance with given callable and kwargs"""
|
|
if name is None:
|
|
name = reflection.get_callable_name(execute)
|
|
super(FunctorTask, self).__init__(name, provides=provides)
|
|
self._execute = execute
|
|
self._revert = revert
|
|
if version is not None:
|
|
self.version = version
|
|
self.rebind = _build_arg_mapping(self.name, requires, rebind,
|
|
execute, auto_extract)
|
|
|
|
def execute(self, *args, **kwargs):
|
|
return self._execute(*args, **kwargs)
|
|
|
|
def revert(self, *args, **kwargs):
|
|
if self._revert:
|
|
return self._revert(*args, **kwargs)
|
|
else:
|
|
return None
|