Make PintoServerQuerier interface generic.

Modify PintoServerQuerier interface so it only assumes it will get
reports from each server on the region covered by the server, the
largest object on the server, and generic query updates. The query
updates are just byte strings instead of being specific to solid angle
queries. They could encode any kind of update -- e.g. replacing a
solid angle query entirely or just issuing commands for cut
management.

Correspondingly, make the PintoServerQuerierListener interface more
generic and complete by using ProximityUpdates to report results
instead of just two callbacks for add/remove with ServerIDs. This lets
us do more than just return a list of results. This is useful for
being able to replicate the top-level tree, but also if we wanted to
make top-level pinto generate aggregates since we would then be able
to return additional properties with the top-level pinto results.

Both of these are a bit odd, but are the simplest ways to make these
interfaces generic. For the querier interface, using a string means we
need to serialize/deserialize update requests just to pass them
between two classes running on the same server because the pinto
querier object and proximity interfaces are decoupled. For the
listener, we're using proximity updates, which really only deal with
object identifiers, so we need to shoe-horn the server identifiers
into them.
Move tracking of max object size into LibproxProximityBase.

This functionality is straightforward and required for using the
PintoServerQuerier interface managed by LibproxProximityBase, so we
can just reuse it for all implementations. This makes it so
implementations should only need to send query updates to top-level
pinto.
Refactor master-pinto code to support solid angle and manual queries.

Refactor the master-pinto code, which used to be a single simple
class, into three classes, much like the proximity code. The base
class handles basic connectivity to the server and the subclasses only
need to deal with sending query updates and receiving results. This
also adds the class for handling manual queries, but currently it's
just a clone of the aggregate solid angle query version since we need
pinto server support for manual queries as well before we can
implement manual querying.
Refactor PintoManager to prepare for addition of manual PintoManager.

Refactor PintoManager into a base class and a specialization that
deals witha specialization. The base class handles the basic
connections and the implementation performs the actual querying and
handles query-format-specific messaging, i.e. anything besides the
basic tracking of ServerID, server region, and largest object.

In doing this, the format of pinto query updates was changed from the
solid angle query PBJ message to a simple byte array so the interface
in PintoManager could be set to its final form. This required updating
the existing clients of PintoManager, the MasterPintoServerQuerier
classes, to serialize a QueryUpdate message into this field instead of
embedding it directly as used to be possible.
Add ManualPintoManager and adjust MasterPintoManualServerQuerier to work with it.

Add ManualPintoManager which uses a manual query processor, accepting
json-encode commands to traverse the tree and returns replicated tree
nodes instead of individual servers as results. This also required a
few changes to PintoManagerLocationServiceCache to expose data that is
now needed to return those complete results.

Also adjust MasterPintoManualServerQuerier to work with this interace,
which is actually a drastic simplification since it assumes it's
client (Proximity implementation) will maintain the replicated tree
and decide how to traverse. To make this work, the interface for
MasterPintoServerQuerierBase needed to be made a bit more generic,
avoiding MasterPinto.pbj messages and using opaque byte-string
messages instead.
Refactor utility loc and pinto related classes into new libpintoloc library.

Extract a bunch of classes that are going to be useful on both the
space server and object host for performing query processing, and
tracking loc state when data is replicated, into a new libpintoloc
library. Currently its all just existing utility code, such as
LocUpdate and its implementations, OrphanLocUpdateManager refactored
to not rely on OH-specific classes, and OHLocationServiceCache renamed
to ReplicatedLocationServiceCache. The TimeSynced interface and an
implementation using the ObjectHost is added to remove the one
dependency the OrphanLocUpdateManager had on liboh.
Factor ManualReplicatedClient out of ServerQueryHandler.

Refactor ServerQueryHandler, moving the core functionality of managing
the remote replicated tree and pushing the data into a
LocationServiceCache into a separate, reusable class,
ManualReplicatedClient, in libpintoloc.

ManualReplicatedClient deals with handling prox and loc messages,
resolves orphan loc updates, and then generates output in the form of
LocationServiceCache entries. It also accepts input specifying which
nodes are being observed so it can decide when to refine the tree.

The user of the class, ServerQueryHandler in this case, is responsible
for injecting loc and prox events, information about which nodes are
observed. It also gets events indicating when new trees are replicated
(since there may be multiple trees for a single server,
e.g. static/dynamic or rebuilding) and for sending (opaque) commands
to the server to control the cut.
Make sure Proximity system tests don't run until after HTTP object control tests have run.
Use ManualReplicatedClient to make LibproxManualProximity interact with ManualPintoManager.

Add ManualReplicatedClient based on space server IDs to
LibproxManualProximity, currently using only NullServerID to handle
events from the PintoServerQuerier. This triggers the creation of a
ManualReplicatedClient and a few helper methods complete the basic
messaging, forwarding query update requests to the
ServerQuerier. Currently only the initial exchange is happening
because a query handler isn't yet being used, meaning usage on the
nodes is not reported.

Other changes were necessary to make this work. Duplicate
ProxSimulationTraits files were removed, preferring a single copy in
libpintoloc. A NopTimeSynced implementation was added to be used when
no time sync is necessary or available. PintoManager now needs
aggregates, so PintoManagerLocCache was updated to support those,
PintoManagerBase implements the libprox AggregateListener interface
and forwards the events to PintoManagerLocCache, and
ManualPintoManager sets itself up as a listener for aggregate
events. ManualPintoManager also needed to report a bit more
information with results -- a timestamp that is required in the pbj
definition and IndexProperties which the client uses to know when to
create a new index.
Allow pinto to load options from a config file.
Allow space server's pinto setting to be overridden from a config file in the server-cluster test script.
Add commander support to pinto binary, make server-cluster script enable it.
Make all query processor classes, including the PintoManagers, provide a base set of commands.

Add BaseProxCommandable class to register a base set of commands for
query processor classes to handle and define pure virtual handlers for
them so subclasses must implement the commands. Use this to simplify
registration of these commands on the object host
(ObjectQueryProcessor), space (Proximity), and pinto
(PintoManagerBase). Add the implementation of these handlers for the
PintoManager classes.
Remove now unnecessary handlerShouldHandleObject method in manual query processor.

libprox has been updated to not require this if it will always return
true, so we can safely remove it now.
Remove UUIDProxSimulationTraits.

This was leftover because the space server was originally written
around UUIDs rather than ObjectReferences. However, it'll cause
problems in reusing some of the libpintoloc code, which needs query
processors to use the same types. This removes
UUIDProxSimulationTraits, adjusting the libprox space plugins to work
with ObjectProxSimulationTraits and performs the necessary
translations between UUID and ObjectReference since the Proximity
interface and some others from the space server still use UUIDs.
Fix parsing of query handler names for ObjectQueryProcessor external commands.
Fix interface for injecting querier events into ManualReplicatedClient.

The existing interface only took an object ID, but since an object
could appear across multiple replicated trees, we actually need to
inject both the ProxIndexID and ObjectReference. This changes that
interface and updates related classes. ObjectQueryHandler needs to now
maintain an extra index of ProxAggregator ->
ProxIndexID. ManualReplicatedClient needs to use a combination of
ProxIndexID and ObjectReference for unobserved timeouts to make sure
it only coarsens the node in a single index. As result, this also now
includes the index in refine/coarsen requests.
Move framing out of ManualReplicatedClient.

Framing isn't necessary for all users, in particular
LibproxManualProximity doesn't need it, so we shouldn't do framing
inside ReplicatedClient. It is, however, required for the
ServerQueryHandler since the OH and space server use framed messages
for prox, so add framing to those messages.
Move Protocol::Prox::QueryRequest wrapping out of ManualReplicatedClient.

As with the previous commit's Frame'ing, this isn't necessary for all
users of this class, in particular it shouldn't be there for
communication with ManualPintoManager.
Merge remote branch 'origin/master' into manual-query

Conflicts:
	build/cmake/CMakeLists.txt