org.neo4j.kernel.ha

Class UpdatePuller

java.lang.Object

org.neo4j.kernel.ha.UpdatePuller

All Implemented Interfaces:

Runnable, org.neo4j.kernel.lifecycle.Lifecycle

public class UpdatePuller
extends Object
implements Runnable, org.neo4j.kernel.lifecycle.Lifecycle

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 {@link UpdatePuller#poke() 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 -------------------->({@link MasterImpl master})
           /                                   |
          |                                   /
          | v--------------------- 2 --------
       ({@link MasterClient slave})
       | ^ \
       | |   -------- 3 -----
       | \                   \
       |  \                   v
       |   ---- 8 -----------({@link TransactionCommittingResponseUnpacker response unpacker})
       |                        |     ^
       9                        |     |
    (continue)                  4     7
                                |     |
                                v     |
                             ({@link UpdatePullingTransactionObligationFulfiller obligation fulfiller})
                                |     ^
                                |     |
                                5     6
                                |     |
                                v     |
                            ({@link UpdatePuller update puller})

 

In the above picture:

1. Slave issues request to master, for example for locking an entity
2. Master responds with a {@link TransactionObligationResponse 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 {@link UpdatePullingTransactionObligationFulfiller obligation fulfiller}...
5. ...which will ask the {@link UpdatePuller update puller}, a separate thread, to have that transaction committed and applied. The calling thread will gently wait for that to happen.
6. The {@link UpdatePuller 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 {@link TransactionIdStore#getLastClosedTransactionId() last applied transaction} will notice when the obligation has been fulfilled.
7. Response unpacker finishes its call to {@link TransactionObligationFulfiller#fulfill(long) 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, {@link TransactionStream transaction data} is received and applied to store directly, in batches.

Field Summary

Fields

Modifier and Type	Field and Description
static org.neo4j.kernel.ha.UpdatePuller.Condition	NEXT_TICKET

Method Summary

Methods

Modifier and Type	Method and Description
boolean	await(org.neo4j.kernel.ha.UpdatePuller.Condition condition, boolean strictlyAssertActive) Gets the update puller going, if it's not already going, and waits for the supplied condition to be fulfilled as part of the update pulling happening.
void	init()
boolean	isActive()
void	pause()
void	run()
void	shutdown()
void	start()
void	stop()
String	toString()
void	unpause()

Methods inherited from class java.lang.Object

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

Field Detail

NEXT_TICKET

public static final org.neo4j.kernel.ha.UpdatePuller.Condition NEXT_TICKET

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

Throws:

Throwable

start

public void start()

Specified by:

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

stop

public void stop()

Specified by:

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

shutdown

public void shutdown()
              throws Throwable

Specified by:

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

Throws:

Throwable

pause

public void pause()

unpause

public void unpause()

await

public boolean await(org.neo4j.kernel.ha.UpdatePuller.Condition condition,
            boolean strictlyAssertActive)
              throws InterruptedException

Gets the update puller going, if it's not already going, and waits for the supplied condition to be fulfilled as part of the update pulling happening.

Parameters:

condition - Condition to wait for.

strictlyAssertActive - if true then observing an inactive update puller, whether halted or paused, will throw an IllegalStateException, otherwise if false just stop waiting and return false.

Returns:

whether or not the condition was met. If strictlyAssertActive either true will be returned or exception thrown, if puller became inactive. If !strictlyAssertActive and puller became inactive then false is returned.

Throws:

InterruptedException - if we were interrupted while awaiting the condition.

IllegalStateException - if strictlyAssertActive and the update puller became inactive while awaiting the condition.

isActive

public boolean isActive()

toString

public String toString()

Overrides:

toString in class Object