For a local process based executor usage currently to ensure
that task emitted notifications are proxied we use the multi
processing library and use its queue concept. This sadly creates
a proxy process that gets associated, and this proxy process
handles the queue and messages sent to and from it. Instead of
doing this we can instead just create a temporary local socket
using a random socket and have tasks (which are running in
different processes) use that to communicate back any emitted
notifications instead (and we can use the asyncore module to handle
the emitted notifications since it handles the lower level socket
reading, polling and dispatching).

To ensure that the socket created is somewhat secure we use a
similar process as the multi-processing library uses where we
sign all messages with a hmac that uses a one time key that only
the main process and the child process know about (and reject
any messages that do not validate using this key).

Change-Id: Iff9180054bf14495e5667af00ae2fafbdbc23791

The docs no longer matched reality.

Change-Id: I9ee98e16fc03489569bbed8355416a73f7bc02ff
Closes-Bug: 1579890

Change-Id: Id9adbc50bd51adc77ce88f698ad0ea2ee63fc5e2

Using a timestamp as value for "html_last_updated_fmt" isn't good
for the reproducible builds initiative from different downstream
distributions because the build result always differs due to the
timestamp in the documentation.
Also when not setting "html_last_updated_fmt", the value can be set
via command line when running "sphinx-build -D".

Change-Id: Ic8912e95e8e298fede1d94c20d3167d1f206df1e

When building packages if git is absent, then we should
fall back to a safe default.

Closes-Bug: #1552251
Change-Id: Ife309625a380cf7d5cc42581ed6d8f9f72b86cd9

Remove some of the usage of @property as none of
these objects are publicly exposed (or have docstrings
on them) to save some space/lines of code that aren't
really adding any benefit.

Use less **kwargs when we know exactly what the keyword
arguments will or will not be. Being explicit makes it
easier to understand these functions (vs not knowing what
the arguments can or can't be).

Removes base worker finder because right now we only
have one implementation (at some point we will have
two) but we can just wait to add a base class until
then.

Change-Id: I7107ff6b77a355b4c5d301948355fb6386605388

Change-Id: Ifdf275a623352aa3e42fbf0aa9a4394b64b54337

This fixes the sporadic of tasks that would happen
under certain circumstances. What happened was that
a new worker notification would be sent to a callback
while at the same time a task submission would come in
and there would be a small race period where the task
would insert itself into the requests cache while the
callback was processing.

So to work around this the whole concept of a requests
cache was revamped and now the WBE executor just maintains
its own local dictionary of ongoing requests and accesses
it safely.

During the on_wait function that is periodically called
by kombu the previous expiry of work happens but now any
requests that are pending are matched to any new workers
that may have appeared.

This avoids the race (and ensures that even if a new
worker is found but a submission is in progress that the
duration until that submission happens will only be until
the next on_wait call happens).

Related-Bug: #1431097

Change-Id: I98b0caeedc77ab2f7214847763ae1eb0433d4a78