/**
* Record time-stamped information about the activity of the connection. This information can
* originate from either the connector or from the framework. The reason it is here is that it is
* viewed as 'belonging' to an individual connection, and is segregated accordingly.
*
* @param connectionName is the connection to which the record belongs. If the connection is
* deleted, the corresponding records will also be deleted. Cannot be null.
* @param startTime is either null or the time since the start of epoch in milliseconds (Jan 1,
* 1970). Every activity has an associated time; the startTime field records when the activity
* began. A null value indicates that the start time and the finishing time are the same.
* @param activityType is a string which is fully interpretable only in the context of the
* connector involved, which is used to categorize what kind of activity is being recorded.
* For example, a web connector might record a "fetch document" activity, while the framework
* might record "ingest document", "job start", "job finish", "job abort", etc. Cannot be
* null.
* @param dataSize is the number of bytes of data involved in the activity, or null if not
* applicable.
* @param entityIdentifier is a (possibly long) string which identifies the object involved in the
* history record. The interpretation of this field will differ from connector to connector.
* May be null.
* @param resultCode contains a terse description of the result of the activity. The description
* is limited in size to 255 characters, and can be interpreted only in the context of the
* current connector. May be null.
* @param resultDescription is a (possibly long) human-readable string which adds detail, if
* required, to the result described in the resultCode field. This field is not meant to be
* queried on. May be null.
* @param childIdentifiers is a set of child entity identifiers associated with this activity. May
* be null.
*/
public void recordHistory(
String connectionName,
Long startTime,
String activityType,
Long dataSize,
String entityIdentifier,
String resultCode,
String resultDescription,
String[] childIdentifiers)
throws ManifoldCFException {
long endTimeValue = System.currentTimeMillis();
long startTimeValue;
if (startTime == null) startTimeValue = endTimeValue - 1L;
else {
startTimeValue = startTime.longValue();
if (startTimeValue == endTimeValue) startTimeValue -= 1L; // Zero-time events are not allowed.
}
long dataSizeValue;
if (dataSize == null) dataSizeValue = 0L;
else dataSizeValue = dataSize.longValue();
Long rowID =
historyManager.addRow(
connectionName,
startTimeValue,
endTimeValue,
dataSizeValue,
activityType,
entityIdentifier,
resultCode,
resultDescription);
// child identifiers are not stored, for now.
// MHL
}
public void run() {
resetManager.registerMe();
try {
// Create a thread context object.
IThreadContext threadContext = ThreadContextFactory.make();
IJobManager jobManager = JobManagerFactory.make(threadContext);
IRepositoryConnectionManager connectionMgr =
RepositoryConnectionManagerFactory.make(threadContext);
IDBInterface database =
DBInterfaceFactory.make(
threadContext,
ManifoldCF.getMasterDatabaseName(),
ManifoldCF.getMasterDatabaseUsername(),
ManifoldCF.getMasterDatabasePassword());
// Loop
while (true) {
// Do another try/catch around everything in the loop
try {
// Before we begin, conditionally reset
resetManager.waitForReset(threadContext);
// Accumulate the wait before doing the next check.
// We start with 10 seconds, which is the maximum. If there's a service request
// that's faster than that, we'll adjust the time downward.
long waitTime = 10000L;
if (Logging.threads.isDebugEnabled()) Logging.threads.debug("Checking for deleting jobs");
// See if there are any starting jobs.
// Note: Since this following call changes the job state, we must be careful to reset it
// on any kind of failure.
JobDeleteRecord[] deleteJobs = jobManager.getJobsReadyForDelete(processID);
try {
if (deleteJobs.length == 0) {
ManifoldCF.sleep(waitTime);
continue;
}
if (Logging.threads.isDebugEnabled())
Logging.threads.debug(
"Found " + Integer.toString(deleteJobs.length) + " jobs ready to be deleted");
long currentTime = System.currentTimeMillis();
// Loop through jobs
int i = 0;
while (i < deleteJobs.length) {
JobDeleteRecord jsr = deleteJobs[i++];
Long jobID = jsr.getJobID();
try {
jobManager.prepareDeleteScan(jobID);
// Start deleting this job!
jobManager.noteJobDeleteStarted(jobID, currentTime);
jsr.noteStarted();
} catch (ManifoldCFException e) {
if (e.getErrorCode() == ManifoldCFException.INTERRUPTED)
throw new InterruptedException();
if (e.getErrorCode() == ManifoldCFException.DATABASE_CONNECTION_ERROR) throw e;
// We cannot abort the delete startup, but if we fall through, we'll put the job
// back into
// the state whence it came. So, fall through.
Logging.threads.error("Exception tossed: " + e.getMessage(), e);
}
}
} finally {
// Clean up all jobs that did not start
ManifoldCFException exception = null;
int i = 0;
while (i < deleteJobs.length) {
JobDeleteRecord jsr = deleteJobs[i++];
if (!jsr.wasStarted()) {
// Clean up from failed start.
try {
jobManager.resetStartDeleteJob(jsr.getJobID());
} catch (ManifoldCFException e) {
exception = e;
}
}
}
if (exception != null) throw exception;
}
// Sleep for the retry interval.
ManifoldCF.sleep(waitTime);
} catch (ManifoldCFException e) {
if (e.getErrorCode() == ManifoldCFException.INTERRUPTED) break;
if (e.getErrorCode() == ManifoldCFException.DATABASE_CONNECTION_ERROR) {
resetManager.noteEvent();
Logging.threads.error(
"Start delete thread aborting and restarting due to database connection reset: "
+ e.getMessage(),
e);
try {
// Give the database a chance to catch up/wake up
ManifoldCF.sleep(10000L);
} catch (InterruptedException se) {
break;
}
continue;
}
// Log it, but keep the thread alive
Logging.threads.error("Exception tossed: " + e.getMessage(), e);
if (e.getErrorCode() == ManifoldCFException.SETUP_ERROR) {
// Shut the whole system down!
System.exit(1);
}
} catch (InterruptedException e) {
// We're supposed to quit
break;
} catch (OutOfMemoryError e) {
System.err.println("agents process ran out of memory - shutting down");
e.printStackTrace(System.err);
System.exit(-200);
} catch (Throwable e) {
// A more severe error - but stay alive
Logging.threads.fatal("Error tossed: " + e.getMessage(), e);
}
}
} catch (Throwable e) {
// Severe error on initialization
System.err.println("agents process could not start - shutting down");
Logging.threads.fatal("StartDeleteThread initialization error tossed: " + e.getMessage(), e);
System.exit(-300);
}
}