de.aristaflow.adept2.core.orgmodelmanager.extension

Class AbstractSyncService<T extends AbstractAuthenticatedService>

java.lang.Object

de.aristaflow.adept2.base.service.AbstractSubService<T>

de.aristaflow.adept2.core.orgmodelmanager.extension.AbstractSyncService<T>

Type Parameters:

T - The type of the service this sync service is a sub service of.

public abstract class AbstractSyncService<T extends AbstractAuthenticatedService>
extends AbstractSubService<T>

An abstract implementation for synchronising org model extensions.

Field Summary

Fields

Modifier and Type	Field and Description
protected LoggingScheduledThreadPoolExecutor	executorService This executor service will be used to schedule the synchronisation.
protected long	period The period of the default synchronisation.
protected java.util.concurrent.atomic.AtomicLong	sequence The transient sequence used if no sequence ID is provided.
protected java.lang.String	sequenceId The ID of the SQL sequence used for retrieving unique ascending IDs for synchronisation runs.
protected java.util.concurrent.ScheduledFuture<?>	synchronisation The future for the currently scheduled synchronisation.
protected java.lang.String	syncType An arbitrary string used for logging messages and thread names.
protected TxManager<SessionToken>	txManager

Fields inherited from class de.aristaflow.adept2.base.service.AbstractSubService

logger, runtimeRequiredServices, service, startupRequiredServices

Constructor Summary

Constructors

Constructor and Description
AbstractSyncService(T omm, TxManager<SessionToken> txManager, java.lang.String syncType, long syncPeriod) Creates a new service for synchronising objects from org model extension with the org model entities and relations.
AbstractSyncService(T omm, TxManager<SessionToken> txManager, java.lang.String syncType, long syncPeriod, java.lang.String sequenceId) Creates a new service for synchronising objects from org model extension with the org model entities and relations.

Method Summary

Modifier and Type	Method and Description
protected SessionToken	createSession() Creates a session token to start the synchronisation after starting.
protected abstract java.lang.Runnable	createSyncRunnable() Creates a runnable that performs the actual synchronisation.
long	getRunId(SessionToken session) Gets the unique and ascending ID for the next synchronisation run.
void	init() Initialise the sub service.
void	scheduleSync(SessionToken session, long start, long period) Schedules a new synchronisation running regularly with the designated period.
void	shutdown(boolean emergency) Signals this service that it is being shut down.
void	start() Starts the sub service.
java.util.concurrent.ScheduledFuture<?>	startDelayedSync(SessionToken session, long delayMillis, boolean logException, boolean rethrow) Starts the synchronisation to run asynchronously right after calling this method.
java.util.concurrent.Future<java.lang.Boolean>	startSync(SessionToken session, boolean logException) Starts the synchronisation to run asynchronously right after calling this method.

Methods inherited from class de.aristaflow.adept2.base.service.AbstractSubService

getLocalUris, getRuntimeRequiredServices, getStartupRequiredServices, getURIs, ping, privilegeSession, sessionActive, sessionFinished

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

syncType

protected final java.lang.String syncType

An arbitrary string used for logging messages and thread names.

sequenceId

protected final java.lang.String sequenceId

The ID of the SQL sequence used for retrieving unique ascending IDs for synchronisation runs. If this is null, no sequence will be created but a transient sequence will be used.

sequence

protected final java.util.concurrent.atomic.AtomicLong sequence

The transient sequence used if no sequence ID is provided.

period

protected long period

The period of the default synchronisation. If this is greater than 0, the default synchronisation will be started automatically. If it is 0, the default synchronisation will not be started, negative values are forbidden.

executorService

protected LoggingScheduledThreadPoolExecutor executorService

This executor service will be used to schedule the synchronisation.

synchronisation

protected java.util.concurrent.ScheduledFuture<?> synchronisation

The future for the currently scheduled synchronisation.

txManager

protected final TxManager<SessionToken> txManager

Constructor Detail

AbstractSyncService

public AbstractSyncService(T omm,
                           TxManager<SessionToken> txManager,
                           java.lang.String syncType,
                           long syncPeriod)

Creates a new service for synchronising objects from org model extension with the org model entities and relations. This will only provide a transient sequence for uniquely identifying synchronisation runs.

Parameters:

omm - The org model manager this sub service belongs to which provides session tokens.

syncType - An identifying name for the extension this synchronisation service belongs to.

syncPeriod - The period of the synchronisation. If this is greater than 0, the default synchronisation will be started automatically. If it is 0, the default synchronisation will not be started, negative values are forbidden.

AbstractSyncService

public AbstractSyncService(T omm,
                           TxManager<SessionToken> txManager,
                           java.lang.String syncType,
                           long syncPeriod,
                           java.lang.String sequenceId)

Creates a new service for synchronising objects from org model extension with the org model entities and relations.

Parameters:

omm - The org model manager this sub service belongs to which provides session tokens.

syncType - An identifying name for the extension this synchronisation service belongs to.

syncPeriod - The period of the synchronisation. If this is greater than 0, the default synchronisation will be started automatically. If it is 0, the default synchronisation will not be started, negative values are forbidden.

sequenceId - The ID of the sequence allowing to create unique ascending IDs for synchronisation runs.

Method Detail

init

public void init()
          throws AbortServiceException

Description copied from class: AbstractSubService

Initialise the sub service. Startup-required services may already be used here.
After returning form AbstractSubService.init(), the sub service must be ready for AbstractSubService.start().

This implementation is empty which allows subclasses to omit the initialisation if they do not need one.

Overrides:

init in class AbstractSubService<T extends AbstractAuthenticatedService>

Throws:

AbortServiceException - If this sub service cannot be initialised due to a severe problem, an AbortServiceException will be thrown. AbstractSubService.shutdown(boolean) will not be called when aborting; the sub service has to shut down itself/clean up before throwing the exception.

start

public void start()
           throws AbortServiceException

Description copied from class: AbstractSubService

Starts the sub service. This method is executed exactly once by the registry and it must return to start further services. For a stand-alone-service own threads or processes have to be started here.
After returning from AbstractSubService.start(), the service must be ready to receive any API call. This implicates for instance, that the thread calling this method may not leave the method before a server thread is actually ready to receive requests.

This implementation is empty which allows subclasses to omit the start procedure if they do not need one.

Overrides:

start in class AbstractSubService<T extends AbstractAuthenticatedService>

Throws:

AbortServiceException - If this sub service cannot be started due to a severe problem, an AbortServiceException will be thrown. AbstractSubService.shutdown(boolean) will not be called when aborting; the sub service has to shut down itself/clean up before throwing the exception.

shutdown

public void shutdown(boolean emergency)

Description copied from class: AbstractSubService

Signals this service that it is being shut down. While this method is called, the service is no longer (remotely) available. It should terminate and close all activities and connections. Since the service is in an inconsistent state while shutting down, access should be restricted to the threads relevant for shutting down. All other requests should be blocked (see ServiceThreadHandling.
All startup required services are available in shutdown, runtime services may already be shut down.
In case of an emergency shutdown, even startup required services may not be available. Additionally, shutting down should be rather fast, so cleanup should concentrate on the really important things and use brief timeouts when waiting.

This implementation is empty.

Overrides:

shutdown in class AbstractSubService<T extends AbstractAuthenticatedService>

Parameters:

emergency - Whether the shutdown will be an emergency shutdown.

startSync

public java.util.concurrent.Future<java.lang.Boolean> startSync(SessionToken session,
                                                                boolean logException)

Starts the synchronisation to run asynchronously right after calling this method. If a regular synchronisation is already running, this manual synchronisation will run right afterwards. An exception occurring while synchronising may be automatically logged. It will always be provided via the returned future. If logException is set to false, make sure to check the returned future, especially for exceptions.

Parameters:

session - The session which is used to check for access rights on this method.

logException - Whether to additionally log an exception occurring while synchronising. If false, make sure to check the returned future, especially for exceptions.

Returns:

The future for the manual synchronisation. This allows to control the synchronisation.

startDelayedSync

public java.util.concurrent.ScheduledFuture<?> startDelayedSync(SessionToken session,
                                                                long delayMillis,
                                                                boolean logException,
                                                                boolean rethrow)

Starts the synchronisation to run asynchronously right after calling this method. If a regular synchronisation is already running, this manual synchronisation will run right afterwards.
If runtime exception or virtual machine error occurs, this can be logged. If it is logged, it can be rethrown. Rethrowing will only makes sense if you are about to check the returned future. If logException is set to false, make sure to check the returned future after the delay, especially for exceptions.

Parameters:

session - The session which is used to check for access rights on this method.

delayMillis - Number of milliseconds the sync will be delayed. If less than or equal zero, the synchronisation will be started immediately.

logException - Whether to additionally log an exception occurring while synchronising. If false, make sure to check the returned future after the delay, especially for exceptions.

rethrow - Whether to rethrow the logged runtime exception/virtual machine error. This parameter will be ignored if logException is false.

Returns:

The future for the manual synchronisation. This allows to control the synchronisation.

scheduleSync

public void scheduleSync(SessionToken session,
                         long start,
                         long period)

Schedules a new synchronisation running regularly with the designated period. The first run will be at the designated start time. If there is currently a scheduled synchronisation, this will be cancelled. If a (scheduled or manual) synchronisation is currently running, the first run of the new synchronisation will be deferred until the other synchronisation has finished.

Parameters:

session - The session which is used to check for access rights on this method.

start - The absolute time (starting on 1970-01-01 00:00 UTC in milliseconds) when to start the synchronisation. If this is in the past, the next run is calculated based on the period starting from this time. The first run may be delayed more in case a currently running synchronisation does not terminate before.
If you want an initial delay, provide System.currentTimeMillis() + initialDelay.

period - The time between the start of consecutive synchronisations. Synchronisations will have a fixed rate/frequency.

getRunId

public long getRunId(SessionToken session)

Gets the unique and ascending ID for the next synchronisation run. If no sequence ID is provided, a transient sequence will be used instead of a database sequence. Note that this is transient and therefore leads to non-unique IDs.

Parameters:

session - The session token identifying the synchronisation run.

Returns:

The next ID for the synchronisation run.

Throws:

InternalServiceException - If there are problems retrieving the next ID from the database sequence, an InternalServiceException will be thrown.

createSession

protected SessionToken createSession()

Creates a session token to start the synchronisation after starting.

Returns:

A newly created session token.

createSyncRunnable

protected abstract java.lang.Runnable createSyncRunnable()

Creates a runnable that performs the actual synchronisation.

Returns:

The runnable performing the actual synchronisation.