This library no longer supports Python 2, thus usage of six can be
removed. This also removes workaround about pickle library used in
Python 2 only.

Change-Id: I19d298cf0f402d65f0b142dea0bf35cf992332a9

This adds a executor backed job dispatching base class
and has the existing blocking executor use it by running jobs
and dispatching jobs into a sync executor. It also allows
for dispatching jobs into a thread executor, or other executor
via a new '_executor_factory' method that can generate
executors (it can be overriden in the non-blocking executor
to provide your own executors instances).

This does alter the behavior in that now that jobs are dispatched
into an executor we no longer can immediatly know if a job was
dispatched and raised an exception or whether it will raise an
exception in the future, so we now alter the 'local_dispatched'
to just be a boolean that is used to determine if any dispatches
happened (failure or not).

Change-Id: I485770e8f4c85d3833892a453c9fb5168d8f0407

Change-Id: If89baa042695f19e42b6368034f3ccf22c2cf0aa

Fixes bug 1445827

Depends-On: I02e3c9aacef0b295a2f823a5cbaf11768a90cb82

Change-Id: I1db681803598ac1bc917fd74a99458bc61edf3f1

Instead of having later checks to check for
none when calling the thread bundle callback
just initially set it to a no-op functor that
does nothing at binding time instead; this avoids
the need to do repeated checks at start/stop
time.

Change-Id: I5ab4f801bf4767c802ea607fdf864d4852e6c84d

Instead of stopping in first started to last started
which is typically not desired (this is the starting
order) we should do the reverse and stop in last to
first instead (which is typically the expected
stopping order) by default.

Change-Id: Ic579438bc549d380c62c4d56c55c168de425adeb

To make it easier to create a bunch of threads in a single
call (and stop them in a single call) create a concept of
a thread bundle (similar to a thread group) that will call
into a provided set of factories to get a thread, activate
callbacks to notify others that a thread is about to start
or stop and then perform the start or stop of the bound
threads in a orderly manner.

Change-Id: I7d233cccb230b716af41243ad27220b988eec14c

Since we support various executors (threaded and distributed)
the next best executor when a threaded executor will not perform
and a distributed one requires to much setup is a local process
based one so it would be great to support this where we can.

Things that are currently (likely never) not going to work:

 * Non-pickleable/non-copyable tasks
 * Tasks that return non-pickleable/non-copyable results
 * Tasks that use non-pickleable/non-copyable args/kwargs

Part of blueprint process-executor

Change-Id: I966ae01d390c7217b858db3feb2db949ce5c08d1

Instead of blocking up the whole test suite when a latch or
event was not decremented to its desired value (or not set for
an event) we should use a reasonably high value that we use
when waiting for those actions to occur and verify that when those
wait() functions return that we have reached the desired state and
if not either raise an exception or stop further testing.

Fixes bug 1363739

Change-Id: I8b40282ac2db9cabd48b0b65c8a2a49610d77c4f

With the new six version we can remove some
of the utility functions that we created now
that upstream six has equivalent or better
functionality.

Change-Id: I637fcf1475ca1af02608e736ca920c3e116c5529