Also allows for people to create Atom's with a different rebind
or requires structure for the revert method, if desired.

Implements blueprint: seperate-revert-args

Change-Id: Ie7d13c8000ef08ff303481d486d1ba1cfbdeea44

* Moved common argument mapping logic to Atom
* Removed BaseTask
* Removed duplicated logic from subclasses

Change-Id: I275745adb80cecb0c35c1230eac76436bf3b0157

Change-Id: I63b65fd40cf029eb6585b82d9c9d9b10108f9183

In situations where many atoms can execute at the same
time it is sometimes useful to denote that when this situation
happens that certain atoms should execute/revert before other
atoms (or at least an attempt should be made to do this) instead
of being nearly arbitrary.

This adds a priority class attribute to the atom class (which
can be overridden or changed as needed) which is then used in
the runtime state machine to sort on so that atoms with higher
priority get submitted (and therefore executed/reverted) first.

Closes-Bug: #1507755

Change-Id: I3dcc705959085cba167883c85278e394b5cb1d2b

Fixes bug 1445827

Depends-On: I02e3c9aacef0b295a2f823a5cbaf11768a90cb82

Change-Id: I1db681803598ac1bc917fd74a99458bc61edf3f1

This change removes the DependencyFailure that is raised when a task
requires the same dependency as it provides. Taskflow returns a
frozenset([]) instead of a frozenset() when more than one value with the
same name is in the store.

This prevents the need for an inconvenient rename function when you want
to update a store variable with a new value.

Example case:
class Inc(task.Task):
    def execute(self, a):
        return a + 1

class AwkwardRename(task.Task):
    def execute(self, b):
        return b

store = {
    'a': 1
}
f = linear_flow.Flow('inc-flow')
f.add(
    Inc('t1',
        provides='b',
        requires='a',
        ),
    AwkwardRename('t2',
                  provides='a',
                  requires='b'))

e = engines.load(f, store=store)
e.run()
print e.storage.fetch('a', many_handler=lambda x: x[-1])

Now with ability to have the same provides as requires:
class Inc(task.Task):
    def execute(self, a):
        return a + 1

store = {
    'a': 1
}
f = linear_flow.Flow('inc-flow')
f.add(
    Inc('t3',
        provides='a',
        requires='a'),
)

e = engines.load(f, store=store)
e.run()
print e.storage.fetch('a', many_handler=lambda x: x[-1])

Change-Id: I421e1ab33508c25baf78bd76df158bb6116d6fb0

Instead of using always using a set/dict which do not retain
use a ordered set and a ordered dict for requires, optional,
and provides and rebind mappings types so that the ordering
of these containers is maintained later when they are used.

These ordering can be useful depending on the atom type (such
as in a map and reduce tasks).

Partial-Bug: 1357117

Change-Id: I365d11bbba4aa221bc36ca15441acecf199b4d56

Since we are mixing properties and attributes in the atom
class it seems better just to standardize on the one that has
the most (attributes) and just mention that they are and should
always be immutable in the atom class documentation.

Depends-On: I18699fc64391445436537854a5e3723f4e89e961

Change-Id: Id03e4229b40b9da5c9a349ee00c13053a9eb75eb

When the requires argument for an Atom is passed in as a string,
each character of the string is iterated over to build up a
requirement list.  This works for simple one letter argument
names but not for long argument names.

Added check for str and unicode types to prevent iterating over a
string.

Change-Id: Ida584221b48966d26935fb2ede0075aabb7ce972

To enforce the already existing behavior that atoms
have execute and revert methods (this is already the
de-facto behavior with its subclasses) we might as
well have the atom class be abstract and have methods
execute() and revert() that need to be implemented
in subclasses (which they already are).

Change-Id: Idfc25a7c2b01f674a065e3f467607eba4ab89a26