Fix the source repository links of the components.

The scm urls in the pom files pointed to the old repositories (e.g. neo4j/community).
They now point to the correct places.
support for chained certificates
support for chained certificates

CA.sh from openssl.org (BSD style license) is used to setup a CA to be used for TestKeyStoreFactory.java
LSB compliance for Ubuntu init script

Provide an init script that is LSB compliant, to wrap the existing start script.  This approach uses PID files to stop the process, which is an idiomatic approach in SYSV-style init scripts.
amending license headers
Chained certificates support

Added some testing such that the original single certificate behaviour is maintained now that the code supports chained certificates. Took the opportunity to inline a bunch of code in the tests (and AbstractNeoServer) too.
Merge pull request #1 from jimwebber/chained_certificates

Chained certificates support
fix for batch operations with https

InternalJettyServletRequest needs to return the correct value for getScheme() as it might be used in the Location header of batch responses.
Start Neo4j with nohup

This prevents Neo4j from exiting when the parent process ends, e.g.
when started via SSH.
Fixes a problem with relationship iterator not seeing new loaded relationships

Problem manifests like this:
Calling node.getRelationships() and iterating through them might give
only a subset of all relationships the first time, compared to subsequent
calls.

Problem distilled to be:
A problem with the chained IdBlocks in RelIdArray objects. To save memory
the IdBlock kept relationship ids as int[], grouped them by the "high bits"
alongside a long containing the high bits separately. Ids <= 0xFFFFFFFF
even has got an IdBlock implementation without a high bits field.
When a new id where added its high bits signature was compared to the last
IdBlock created in the chain of IdBlocks - if matching it was added,
otherwise a new IdBlock was created with that high bits signature, its
"prev" link pointing to the IdBlock that previously was the last one and
the id added to it.
RelIdArray is capable of having three of these chains (out, in, loop).

  (RelIdArray)-[:out]->(A)

  ==> becomes

  (RelIdArray)-[:out]->(B)-[:prev]->(A)

An iterator (RelIdIterator) started from the last created IdBlock (in this
case B) going backwards, iterating through each IdBlock in its wake. After
fully depleting the iterator new relationships might get loaded lazily
(happens the first time a node visits each relationships if not cached).
Loaded ids would always be added to (B) or even a new IdBlock (C) if there was
a high bits signature mismatch, and so the iterator would be left stranded
on (A), never being able to see added ids.

Solution in this commit:
Simplify by removing the concept of chain of IdBlocks and have one
space-efficient IdBlock implementation capable of storing ids <= 0xFFFFFFFF
and another less space-efficient implementation capable of storing any id
and use the upgrade ability (upgrading from the "low" IdBlock to the
"high" IdBlock when needed). This will make sure there's only zero or one
IdBlock for any given direction (out, in, loop) and simpler code. At the
expense of slightly higher memory consumption.

Future solition:
Only have one IdBlock implementation that is capable of efficiently
storing any id, e.g. using a byte[] where each id added only consume least
necessary amount of bytes.
Merge pull request #874 from sarmbruster/chained_certificates

support for chained certificates
Use separate directories for master and slave in ClusterTest
Adds ability to not participate in elections if not eligible for that

This is triggered by slaves asking for and getting elected at elections
 for master while copying the store. This should not be possible as
 the slave is not fit for that role at that moment. Hence, we introduce
 the ability for an HA state to talk about its suitability for master
 election.
Updated the README to something a bit more readable.
Updated the README.
Updated the README.
Updated the README.
Prevents timeouts during long write operations on the master side

Adds a writeComplete() handler on the Server.ServerHandler to update
 the corresponding transaction's timestamp
Properly handles exceptions for finishing channels that do not really
 have corresponding transactions
Introduce and use special class for transaction missing on master

Instead of catching an IllegalStateException, we use a specific
 TransactionNotPresentOnMasterException when the resume of a tx for
 finishing it is not present. That makes the corresponding catch clause
 more specific, avoiding swallowing a potential error.

Also makes sure that writeComplete() in Server.ServerHandler forwards the
 call down the pipeline
Moves Clock and implementations to kernel for usage elsewhere

Clock as an interface is useful for abstracting time. It is moved to kernel
 for usage elsewhere. The real implementation (delegating to System.currentTimeMillis())
 is also moved to kernel main source. The FakeClock dummy is moved to kernel test source.
Updates the current users to use the new import
FakeClock has some utility methods added so it can be more presicely controlled.
The single Clock method is renamed to be the same as the one in System