org.neo4j.kernel.ha

Class SlaveUpdatePuller

java.lang.Object

org.neo4j.kernel.lifecycle.LifecycleAdapter

org.neo4j.kernel.ha.SlaveUpdatePuller

All Implemented Interfaces:

Runnable, UpdatePuller, org.neo4j.kernel.lifecycle.Lifecycle

public class SlaveUpdatePuller
extends org.neo4j.kernel.lifecycle.LifecycleAdapter
implements Runnable, UpdatePuller

Able to pull updates from a master and apply onto this slave database.

Updates are pulled and applied using a single and dedicated thread, created in here. No other threads are allowed to pull and apply transactions on a slave. Calling one of the pullUpdates TransactionObligationFulfiller.fulfill(long) will poke that single thread, so that it gets going, if not already doing so, with its usual task of pulling updates and the caller which poked the update thread will constantly poll to see if the transactions it is obliged to await have been applied.

Here comes a diagram of how the classes making up this functionality hangs together:

             -------- 1 -------------------->(master)
           /                                   |
          |                                   /
          | v--------------------- 2 --------
       (slave)
       | ^ \
       | |   -------- 3 -----
       | \                   \
       |  \                   v
       |   ---- 8 -----------(response unpacker)
       |                        |     ^
       9                        |     |
    (continue)                  4     7
                                |     |
                                v     |
                             (obligation fulfiller)
                                |     ^
                                |     |
                                5     6
                                |     |
                                v     |
                            (update puller)

 

In the above picture:

1. Slave issues request to master, for example for locking an entity
2. Master responds with a transaction obligation telling the slave which transaction it must have applied before continuing
3. The response from the master gets unpacked by the response unpacker...
4. ...which will be sent to the obligation fulfiller...
5. ...which will ask the update puller, a separate thread, to have that transaction committed and applied. The calling thread will gently wait for that to happen.
6. The update puller will pull updates until it reaches that desired transaction id, and might actually continue passed that point if master has more transactions. The obligation fulfiller, constantly polling for last applied transaction will notice when the obligation has been fulfilled.
7. Response unpacker finishes its call to fulfill the obligation
8. Slave has fully received the response and is now able to...
9. ...continue

All communication, except actually pulling updates, work this way between slave and master. The only difference in the pullUpdates case is that instead of receiving and fulfilling a transaction obligation, transaction data is received and applied to store directly, in batches.

See Also:

UpdatePuller

Nested Class Summary

Nested classes/interfaces inherited from interface org.neo4j.kernel.ha.UpdatePuller

UpdatePuller.Condition

Nested classes/interfaces inherited from interface org.neo4j.kernel.lifecycle.Lifecycle

org.neo4j.kernel.lifecycle.Lifecycle.Delegate

Field Summary

Fields

Modifier and Type	Field and Description
static int	AVAILABILITY_AWAIT_MILLIS
static int	LOG_CAP
static long	PARK_NANOS
static String	UPDATE_PULLER_THREAD_PREFIX

Fields inherited from interface org.neo4j.kernel.ha.UpdatePuller

NONE

Method Summary

Methods

Modifier and Type	Method and Description
void	init()
boolean	isActive()
void	pullUpdates() Pull all available updates.
void	pullUpdates(UpdatePuller.Condition condition, boolean strictlyAssertActive) Pull updates and waits for the supplied condition to be fulfilled as part of the update pulling happening.
void	run()
void	shutdown()
String	toString()
boolean	tryPullUpdates() Try to pull all updates

Methods inherited from class org.neo4j.kernel.lifecycle.LifecycleAdapter

start, stop

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Field Detail

LOG_CAP

public static final int LOG_CAP

PARK_NANOS

public static final long PARK_NANOS

AVAILABILITY_AWAIT_MILLIS

public static final int AVAILABILITY_AWAIT_MILLIS

UPDATE_PULLER_THREAD_PREFIX

public static final String UPDATE_PULLER_THREAD_PREFIX

See Also:

Constant Field Values

Method Detail

run

public void run()

Specified by:

run in interface Runnable

init

public void init()
          throws Throwable

Specified by:

init in interface org.neo4j.kernel.lifecycle.Lifecycle

Overrides:

init in class org.neo4j.kernel.lifecycle.LifecycleAdapter

Throws:

Throwable

shutdown

public void shutdown()
              throws Throwable

Specified by:

shutdown in interface org.neo4j.kernel.lifecycle.Lifecycle

Overrides:

shutdown in class org.neo4j.kernel.lifecycle.LifecycleAdapter

Throws:

Throwable

pullUpdates

public void pullUpdates()
                 throws InterruptedException

Description copied from interface: UpdatePuller

Pull all available updates.

Specified by:

pullUpdates in interface UpdatePuller

Throws:

InterruptedException - in case if interrupted while waiting for updates

tryPullUpdates

public boolean tryPullUpdates()
                       throws InterruptedException

Description copied from interface: UpdatePuller

Try to pull all updates

Specified by:

tryPullUpdates in interface UpdatePuller

Returns:

true if all updates pulled, false if updater fail on update retrieval

Throws:

InterruptedException - in case if interrupted while waiting for updates

pullUpdates

public void pullUpdates(UpdatePuller.Condition condition,
               boolean strictlyAssertActive)
                 throws InterruptedException

Description copied from interface: UpdatePuller

Pull updates and waits for the supplied condition to be fulfilled as part of the update pulling happening.

Specified by:

pullUpdates in interface UpdatePuller

Parameters:

condition - UpdatePuller.Condition to wait for.

strictlyAssertActive - if true then observing an inactive update puller will throw an IllegalStateException,

Throws:

InterruptedException - if we were interrupted while awaiting the condition.

isActive

public boolean isActive()

toString

public String toString()

Overrides:

toString in class Object