15b2af47ae
To increase our python3 compatability we should attempt to use the six module for known issues that are likely to happen in python3 when comparing to string types. Change-Id: Ib6fc32138e218c8b45023ca37d87b742694b8349
199 lines
7.2 KiB
Python
199 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
|
|
import six
|
|
|
|
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, six.string_types):
|
|
# 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
|