Copy execution log into normal log when a test fails.
Use reported canonical subfile paths when parsing Collada and when uploading aggregates.

Extract canonical subfile paths from headers (e.g. Subfile-0-Name and
Subfile-0-Path) and replace texture references in the parsed Collada
with full, canonical URLs.

In aggregate manager, rework the generation of subfiles to use these
URLs, or work for non-URL textures. The keys for subfiles are always
the path basename (i.e. just the filename, no parent directories) and
the value is the CDN-style resource path (the name of the asset on the
CDN rather than the exact URL used for download).

Similar to generating the URL for aggregate meshes from the path
reported by the upload process, this requires switching around version
and filenames in URLs -- first when placing URLs in the Meshdata so
that display (i.e. download) will work properly then back to the
original when using the URLs for specifying existing files for
aggregate textures.
Cap the number of outstanding location updates per client.

If a client stops responding but remains connected (i.e. the
underlying TCP connection remains but the client stops responding to
message), an unbounded number of location updates could be sent out,
all of which will eventually fail. This eats up memory as it waits for
stream creation to fail and CPU as retries are performed and thousands
of errors are reported.

To fix this, cap the number of outstanding location updates
permitted. This could slow down the time it takes for all updates to
be received (e.g. longer to learn of the steady state if the scene
reaches it), but it ensures we won't have an unbounded number of
messages. An alternative would have been to use a single stream, but
this approach avoids adding unnecessary ordering constraints on the
messages.  Note that the number of messages is the number of
BulkLocationUpdates, so each message may contain many updates to
individual objects.
Merge branch 'aggregate-upload'
Fix ordering of cleanup in AggregateManager.

The poller which the AggregateManager uses to generate keepalives
depends on the AggregateManager's IOService and IOStrand, but when
cleaned up automatically by the destructor it would finish after they
had been deleted. This allocates it on the heap and deletes it before
the IOService and IOStrand are cleaned up.
ProxyEntity was on the wrong strand in graphics.  Now it's part of the rendering strand.
Tick LocationUpdatePolicy less frequently in BulletPhysicsService.

If you tick LocationUpdatePolicy very quickly in BulletPhysicsService
it generates a lot of updates since moving objects will almost always
need an update. This can result in an overwhelming number of messages,
causing things to get backed up and high latency in actually applying
updates.

This helps with the problem where avatars can get underneath static
terrain. While that can't be fully addressed without additional
changes to BulletPhysicsService, this should help improve the
situation: it increases the average latency of the initial updates
after an object becomes dynamic, but after a few pile up, it actually
decreases the latency since things don't get blocked up and so don't
require retries. It's still possible to use a predicted position which
puts you under the ground, but it's less likely since in these
situations location updates are applied sooner than they are when we
generate a lot more updates.
Cananicalize FILE_EXE path on Mac.

The function used to get the executable's path on Mac can return
paths with relative path components (. and ..). These can interfere
with assumed path offsets.

Add a method for removing these elements (.. only when specifically
requested since doing so is not always safe. Apply this to the
FILE_EXE path generated on Mac.

This addresses an issue where cppoh would just hang on start if
started on Mac with ./ as the first part of the executable path.
Generate an error if CSVObjectFactory can't find the database file. Under detailed, report how many objects were loaded.
Add basic Command interfaces, typedefs, and utilities.

The Command classes will allow processing of external commands. To do
so, an optional central Commander will accept commands, track
handlers, and dispatch to them, finally returning results to the
original requestor.

This adds basic classes, typedefs, and interfaces: Command for
flexibly structured commands, CommandKey for uniquely identifying
commands, CommandHandler for processing an individual command, and
Commmander for coordinating CommandHandlers and accepting external
requests. A field is added to Context to make the Commander "globally"
accessible for registrations, but there isn't yet a full
implementation.
Never actually used keywords in emerson.  More importantly, trying to
reduce shared state in Emerson compiler.  Previous keywords
implementation was unsafe: one could be inserting into keywords while
other was reading.
Add a simple HTTP implementation of Commander.

Add a new plugin that listens for commands via HTTP requests and
dispatches them. Set this as the default for space and implement
single command in Server that returns the number of objects as a
simple test.

The HttpCommander class is relatively simple, but relies on a new
HttpServer class that implements a simple HTTP server. It's built on
the http_parser library and essentially provides the half of HTTP
compared to HttpManager.
Cleaned up a lot of the emerson compiler code (removing unused compile
methods, etc.).  Trying to get to point where can enforce that only
one entity at a time uses antlr.
Removed EmersonInfo memory leak from compiler.  Additionally, all
emersonInfos are no longer shared among all entities.
Prevents synchronous access to antlr (which doesn't support
multi-threading) from multiple entities.
Add explanation of data layout for CassandraStorage.
Change OH::Storage interface to return success or cause of error.

Replace the bool success parameter to OH::Storage callbacks with an
enum that indicates success or the reason for an error. This should
only contain a small, fixed, implementation-independent set of
errors. The two currently included are LOCK_ERROR, indicating an error
with access to the underlying database, and TRANSACTION_ERROR
indicating the transaction failed to apply cleanly (e.g. missing key,
failed comparison). This allows us to expose some aspects of the
underlying database connection abstractly.
Change OH::Storage erases to be successful even when missing.

Storage backends aren't necessarily able to cheaply tell whether an
erase would fail because the key was missing. Instead, change the
semantics to be successful even if the key was missing.

To adjust:
* Add a note to the OH::Storage documentation and indicate that a
  compare + erase can compensate for the change.
* Fix SQLiteStorage to follow the new semantics.
* Change the testRollback to be less effective, but follow the new
  semantics. It tries to test whether rollbacks occur, but can't
  really be effective in the face of command reordering since mutation
  commands generally won't fail due to general storage semantics
  (though they might because of backend-specific problems, such as
  write values that are too large).
* Adjust JS/Emerson storage tests to follow new semantics.
Add lease notifications to OH::Storage interface.

Add methods to OH::Storage to indicate that a bucket should be leased
and unleased. These don't necessarily immediately lease or lock the
bucket, but rather indicate that storage requests may occur and
leasing may be necessary. The releaseBucket is particularly useful
since leases may be acquired on demand, but should be released as soon
as possible.

Add stub implementations in the OH::Storage implementation
classes. Update HostedObject and unit tests to use the new interface.
Add lease support to SQLite storage implementation.

Add leases to SQLite storage implementation. This is relatively
straightforward since SQLite has transactions. The implementation uses
a single lease key-value pair per bucket which indicates the current
owner and expiration of the lease. We use SQLite transactions to
acquire and update the lease safely. Leases are first acquired when
the first request is made for a bucket and released when
releaseBucket() is called. A single renewal queue and timer are used
to schedule the next processing of renewals. An option controls the
standard lease duration so a tradeoff can be made between renewal
overhead and recovery time after a failure that causes a lease to not
be cleaned up.