Fix outdated xref in docs.
Revert "Remove metadata/id from the representation"

This reverts commit 786bbd63768d316c8633bdfb60bfaee2808210a0, and
converts the metadata/id representation to a Long.
Merge pull request #3167 from cleishm/node_metadata

[2.1] Revert "Remove metadata/id from the representation"
Create a filter for dealing with X-Forwarded-*.

Handles X-Forwarded-Host and X-Forwarded-Proto. Moved the handler code out of the OutputFormatProvider into a jetty filter much further down the stack. This should enable all of the Neo4j server resources (including / and /db/manage) to be addressed via an external hostname and other URI scheme.
Merge 2.0-maint into 2.1-maint
Tagging for version 2.1.5
Ability to persist counts durably.

The `rotate()` method of the CountsTracker will read from the current
CountsStore and write to the other CountsStore before making that one
the current. The intention is to invoke rotation of the counts store
when the log rotates, so that the counts store will be kept consistent
even though the commands in the log only contain deltas to apply to the
counts store.

By persisting durably on log rotation only, we will simply restart from
last point-of-rotation if we need to perform recovery on startup.

As of this commit the persisting of counts has not been wired in to the
rest of the database.
Circumvent the PageCache for (stream) reading.

Since the PageCache only supports one cursor per thread, we cannot both
read through the PageCache and write through the PageCache when rotating
the CountsStore. As a workaround we read directly from the file system
when streaming through the source file during rotation.

By not using a cursor when visiting all counts in a store, we gain the
ability to do "self-verification" of the store. Since cursors are pooled
per thread (each thread has a read cursor and a write cursor that it
reuses) the code would become harder to follow if we were to allow doing
`get()` on the store while visiting it, since we would need to find and
reuse the same cursor. As of this change we no longer use cursors when
visiting the store, so we are now able to invoke `get()` from the visitor
and thereby verifying that all values that the visitor sees can also be
looked up from the store.
Integrate persisting counts durably.

Wires in the rotation of the counts store on transaction log rotation.
(Re)Builds the counts store at the end of a batch insert session.
Fix rare corruption bug in the page cache

Here's the scenario we're now guarding against:

* We want to read a page that is not in the cache, so we do a page fault. This
  is fine, the page gets loaded into the cache and added to our translation
  table.
* Then it gets evicted and cleaned. This is also fine, though this is
  inherently racy because we are taking locks in the wrong order. Because of
  the lock-ordering problem, the translation table _may_ not get updated, and
  is exactly what happens in this scenario. The page is now unbound, and in
  both the translation table and in the freelist. This is fine, though, because
  any thread that grabs it will check it with isBoundTo, which will return
  false, and then that thread will do a new page fault.
* As part of the eviction, the filePageId field is set to -1, and the swapper
  field is set to null. This is what makes the page "unbound."
* Then we want to access the page again.
** We first look in our translation table. We do find the page, but because the
   page has been evicted (we can tell by the -1 filePageId and the null
   swapper) we know that our translation table is out of date, so we are going
   to do a page fault anyway.
** We grab a free page from the freelist, so we have a place to fault the file
   page into. By pure chance, _this ends up being the same exact page object!_
** One of the first things that happens when we do a page fault, is that we set
   the filePageId and the swapper fields. _These are now set to the same values
   they had before the page was evicted!_
** The next thing that happens in a page fault is the IO to read the page
   contents from the file into the page in memory. This can fail with various
   IO-related errors, and in our scenario _it does!_
* We now have a page that is correctly placed in the translation table, is
  bound to the right filePageId and swapper, but _has the wrong contents_
  because the page fault ultimately failed.
* The next time we want to access the page, we will find it in the translation
  table, see that it is correctly bound, and proceed to read the wrong
  contents.

Since eviction will only consider pages that are "loaded" (aka. not already
free), the fix is the following: The isLoaded already only considered whether
the filePageId field was set or not, so it is possible to make a page appear
loaded for the purpose of eviction, while at the same time making the isBountTo
check always fail. Instead of assigning the filePageId and swapper _before_
doing the swapIn IO, we move the assignment of the swapper field down so it
happens _after_ the page has been successfully swapped in, while leaving the
assignment of the filePageId field where it is. This means that a page that
fails in swapIn will appear loaded for the purpose of eviction, while leaving
no room for it to be confused with a bound page.
Fixes stop() process in TransactionCommittingResponseUnpacker

TCRU uses the TransactionIdStore to update committing and applying
 tx ids, as expected by the tx commit protocol. However, if a stop()
 was issued, the txIdStore field would be set to null and if this
 happened during a tx apply where the txIdStore.transactionCommitted()
 call had already gone through, the subsequent transactionClosed() event
 would fail with a NPE. This would leave the txIdStore waiting for a
 transaction to apply, which would prohibit the database from shutting
 down.
 This patch removes the setting to null on stop approach and uses
 a boolean to mark the stopped state in TCRU, not allowing any
 more transactions to go through and allowing the shutdown to finish.
Performs log pruning outside of append monitors

so that log pruning, which isn't critical functionality in and around
transaction appends and rotations, outside of any monitors held by
append/rotate. This will make the pauses introduced by rotation smaller so
that other transactions can still append when a log pruning is happening.
Back to development version.
2.1.5-SNAPSHOT -> 2.1.6-SNAPSHOT
Merged 2.1-maint into master
Merge pull request #3180 from cleishm/merge-2.1-into-2.2

[2.2] Merge 2.1 into 2.2
Merge pull request #3187 from tinwelint/2.2-lock-free-prune

[2.2] Performs log pruning outside of append monitors
Merge pull request #3186 from digitalstain/2.2-fix-response-unpacker-stop

[2.2] Fixes stop() process in TransactionCommittingResponseUnpacker
Exceptions in eviction thread now wakes up blocked page faulters.

The problem was that a page faulting thread could make it past the
`assertHealthy()` check, and then park, and then the eviction thread could
encounter an exception and then never tell the parked threads about it. They
would be stuck for however long it woudl take for the eviction thread to
finally evict and free a page for them.

Now, if the eviction thread knows that threads are parked, and it failes to
evict a page, it will instead signal to the parked thread and transfer the
exception to it, instead of a free page. The parked thread will then wake up
and throw the exception.
Logs progress catching up to master in HA

Possible after a refactoring where the response unpacker now accepts a
TxHandler in its accept method. This makes it possible to reuse a single
response unpacker for multiple TxHandler purposes, and by extension a
single MasterClient instance for multiple purposes.