Package org.openbravo.service.importprocess

Class ImportEntryProcessor

java.lang.Object

org.openbravo.service.importprocess.ImportEntryProcessor

Direct Known Subclasses:

VariantChDescUpdateProcessor

@ApplicationScoped
public abstract class ImportEntryProcessor
extends Object

The ImportEntryProcessor is responsible for importing/processing ImportEntry instances for a specific TypeOfData. The ImportEntryProcessor is a singleton/applicationscoped, it implements a generic approach to make to make it possible to do import of ImportEntry in parallel threads ( ImportEntryProcessor.ImportEntryProcessRunnable) if possible. It is important that a specific ImportEntry is assigned to the right processing thread to prevent for example deadlocks in the database. To make this possible a concept of getProcessSelectionKey(ImportEntry) is used. The process selection key is a unique key derived from the ImportEntry which can be used to create/identify the thread which should process the ImportEntry. If no such thread exists a new ImportEntryProcessor.ImportEntryProcessRunnable is created. The exact type of ImportEntryProcessor.ImportEntryProcessRunnable is determined by the extending subclass through the createImportEntryProcessRunnable() method. For example if ImportEntry records of the same organization should be processed after each other (so not in parallel) to prevent DB deadlocks, this means that the records of the same organization should be assigned to the same thread object. So that they are indeed processed sequential and not in parallel. The getProcessSelectionKey(ImportEntry) should in this case return the Organization.getId() so that ImportEntryProcessor.ImportEntryProcessRunnable are keyed/registered using the organization. Other ImportEntry records of the same organization are then processed by the same thread, always sequential, not parallel, preventing DB deadlocks. The ImportEntryManager passes new ImportEntry records to the the ImportEntryProcessor by calling its handleImportEntry(ImportEntry). The ImportEntryProcessor then can decide how to handle this ImportEntry, create a new thread or assign it to an existing thread (which is busy processing previous entries). This is all done in this generic class. An implementing subclass needs to implement the getProcessSelectionKey(ImportEntry) method. This method determines which/how the correct ImportEntryProcessor.ImportEntryProcessRunnable is chosen. The default/base implementation of the ImportEntryProcessor.ImportEntryProcessRunnable provides standard features related to caching of OBContext, error handling and transaction handling. Note: this implementation uses the executorService in the ImportEntryManager. Threads are started by using the ExecutorService.submit(Runnable) method, see ImportEntryManager.submitRunnable(Runnable). Any exceptions inside the Runnable.run() method are swallowed and won't directly show up in the console. Therefore the default implementation in the ImportEntryProcessor.ImportEntryProcessRunnable.run() has different mechanisms to correctly log/record the error (in the ImportEntry.getErrorinfo()). Note: the ImportEntryProcessor should be aware that the same ImportEntry can be passed multiple times to it. Also after the ImportEntryProcessor has already processed it. This can happen because of the parallel/multi-threaded approach followed here. So the ImportEntryProcessor and the implementation of the ImportEntryProcessor.ImportEntryProcessRunnable should correctly and robustly handle this case. The default ImportEntryProcessor.ImportEntryProcessRunnable implementation has mechanism to prevent double processing in some cases. Note: it is save for an ImportEntryProcessor to occasionally not process an ImportEntry. The ImportEntryManager will offer the ImportEntry again in its next cycle. But it is quite important that this only happens if the order of the entries being processed is maintained or not relevant.

Author:

mtaal

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	ImportEntryProcessor.ImportEntryProcessRunnable	The default implementation of the ImportEntryProcessRunnable.

Constructor Summary

Constructors

Constructor	Description
ImportEntryProcessor()

Method Summary

Modifier and Type	Method	Description
protected boolean	assignEntryToThread(String key, ImportEntry importEntry)	Assigns an import entry to a processing thread besed on its type and key.
protected abstract boolean	canHandleImportEntry(ImportEntry importEntryInformation)	Can be used by implementing subclass to check that the ImportEntry can be processed now.
protected abstract ImportEntryProcessor.ImportEntryProcessRunnable	createImportEntryProcessRunnable()	Create a concrete subclass of ImportEntryProcessor.ImportEntryProcessRunnable
protected boolean	enableArchive()	Declares if the import entry will later on be archived after it has been processed
protected abstract String	getProcessSelectionKey(ImportEntry importEntry)	Based on the ImportEntry returns a key which uniquely identifies the thread which should process this ImportEntry.
boolean	handleImportEntry(ImportEntry importEntry)	Is called from the ImportEntryManager thread, passes in a new ImportEntry to process.
void	shutdown()	Is called when the application context/tomcat stops, is called from ImportEntryManager.shutdown().
String	toString()

Methods inherited from class java.lang.Object

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

Constructor Detail

ImportEntryProcessor

public ImportEntryProcessor()

Method Detail

shutdown

public void shutdown()

Is called when the application context/tomcat stops, is called from ImportEntryManager.shutdown().

handleImportEntry

public boolean handleImportEntry(ImportEntry importEntry)

Is called from the ImportEntryManager thread, passes in a new ImportEntry to process. Finds the Thread which can handle this entry, if none is found a new thread is created, if one is found then the ImportEntry is passed/given to it. If the processing of the entry does not happen fast enough then it can be that the ImportEntry is again offered to the ImportEntryProcessor through a call to this method. The implementation should be able to gracefully handle duplicate entries. Also the implementation should check if the ImportEntry was possibly already handled and ignore it then.

Returns:

whether the importEntry has been assigned to a thread for it to be processed

assignEntryToThread

protected boolean assignEntryToThread(String key,
                                      ImportEntry importEntry)

Assigns an import entry to a processing thread besed on its type and key.

Returns:

whether the import entry could be assigned to a thread

createImportEntryProcessRunnable

protected abstract ImportEntryProcessor.ImportEntryProcessRunnable createImportEntryProcessRunnable()

Create a concrete subclass of ImportEntryProcessor.ImportEntryProcessRunnable

canHandleImportEntry

protected abstract boolean canHandleImportEntry(ImportEntry importEntryInformation)

Can be used by implementing subclass to check that the ImportEntry can be processed now. In some cases other ImportEntries should be processed first. By returning false the ImportEntry is ignored for now. It will again be picked up in a next execution cycle of the ImportEntryManager thread and then offered again to this ImportEntryProcessor to be processed.

getProcessSelectionKey

protected abstract String getProcessSelectionKey(ImportEntry importEntry)

Based on the ImportEntry returns a key which uniquely identifies the thread which should process this ImportEntry. Can be used to place import entries which block/use the same records in the same import thread, in this way preventing DB (dead)locks.

enableArchive

protected boolean enableArchive()

Declares if the import entry will later on be archived after it has been processed

toString

public String toString()

Overrides:

toString in class Object