Java tutorial
/******************************************************************************* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. *******************************************************************************/ package org.apache.ofbiz.service.job; import java.io.IOException; import java.sql.Timestamp; import java.util.Date; import java.util.HashMap; import java.util.Map; import javax.xml.parsers.ParserConfigurationException; import org.apache.commons.lang.StringUtils; import org.apache.ofbiz.base.config.GenericConfigException; import org.apache.ofbiz.base.util.Debug; import org.apache.ofbiz.base.util.UtilDateTime; import org.apache.ofbiz.base.util.UtilGenerics; import org.apache.ofbiz.base.util.UtilValidate; import org.apache.ofbiz.entity.Delegator; import org.apache.ofbiz.entity.GenericEntityException; import org.apache.ofbiz.entity.GenericValue; import org.apache.ofbiz.entity.serialize.SerializeException; import org.apache.ofbiz.entity.serialize.XmlSerializer; import org.apache.ofbiz.entity.util.EntityQuery; import org.apache.ofbiz.service.DispatchContext; import org.apache.ofbiz.service.GenericRequester; import org.apache.ofbiz.service.ServiceUtil; import org.apache.ofbiz.service.calendar.RecurrenceInfo; import org.apache.ofbiz.service.calendar.RecurrenceInfoException; import org.apache.ofbiz.service.calendar.TemporalExpression; import org.apache.ofbiz.service.calendar.TemporalExpressionWorker; import org.apache.ofbiz.service.config.ServiceConfigUtil; import org.xml.sax.SAXException; import com.ibm.icu.util.Calendar; /** * A {@link Job} that is backed by the entity engine. Job data is stored * in the JobSandbox entity. * <p>When the job is queued, this object "owns" the entity value. Any external changes * are ignored except the cancelDateTime field - jobs can be canceled after they are queued.</p> */ @SuppressWarnings("serial") public class PersistedServiceJob extends GenericServiceJob { public static final String module = PersistedServiceJob.class.getName(); private final transient Delegator delegator; private long nextRecurrence = -1; private final long maxRetry; private final long currentRetryCount; private final GenericValue jobValue; private final long startTime; /** * Creates a new PersistedServiceJob * @param dctx * @param jobValue * @param req */ public PersistedServiceJob(DispatchContext dctx, GenericValue jobValue, GenericRequester req) { super(dctx, jobValue.getString("jobId"), jobValue.getString("jobName"), null, null, req); this.delegator = dctx.getDelegator(); this.jobValue = jobValue; Timestamp storedDate = jobValue.getTimestamp("runTime"); this.startTime = storedDate.getTime(); this.maxRetry = jobValue.get("maxRetry") != null ? jobValue.getLong("maxRetry").longValue() : -1; Long retryCount = jobValue.getLong("currentRetryCount"); if (retryCount != null) { this.currentRetryCount = retryCount.longValue(); } else { // backward compatibility this.currentRetryCount = getRetries(this.delegator); } } @Override public void queue() throws InvalidJobException { super.queue(); try { jobValue.refresh(); } catch (GenericEntityException e) { throw new InvalidJobException("Unable to refresh JobSandbox value", e); } if (!JobManager.instanceId.equals(jobValue.getString("runByInstanceId"))) { throw new InvalidJobException("Job has been accepted by a different instance"); } Timestamp cancelTime = jobValue.getTimestamp("cancelDateTime"); Timestamp startTime = jobValue.getTimestamp("startDateTime"); if (cancelTime != null || startTime != null) { // job not available throw new InvalidJobException("Job [" + getJobId() + "] is not available"); } else { jobValue.set("statusId", "SERVICE_QUEUED"); try { jobValue.store(); } catch (GenericEntityException e) { throw new InvalidJobException("Unable to set the startDateTime and statusId on the current job [" + getJobId() + "]; not running!", e); } if (Debug.verboseOn()) { Debug.logVerbose("Placing job [" + getJobId() + "] in queue", module); } } } @Override protected void init() throws InvalidJobException { super.init(); try { jobValue.refresh(); } catch (GenericEntityException e) { throw new InvalidJobException("Unable to refresh JobSandbox value", e); } if (!JobManager.instanceId.equals(jobValue.getString("runByInstanceId"))) { throw new InvalidJobException("Job has been accepted by a different instance"); } if (jobValue.getTimestamp("cancelDateTime") != null) { // Job cancelled throw new InvalidJobException("Job [" + getJobId() + "] was cancelled"); } jobValue.set("startDateTime", UtilDateTime.nowTimestamp()); jobValue.set("statusId", "SERVICE_RUNNING"); try { jobValue.store(); } catch (GenericEntityException e) { throw new InvalidJobException("Unable to set the startDateTime and statusId on the current job [" + getJobId() + "]; not running!", e); } if (Debug.verboseOn()) { Debug.logVerbose("Job [" + getJobId() + "] running", module); } // configure any additional recurrences long maxRecurrenceCount = -1; long currentRecurrenceCount = 0; TemporalExpression expr = null; RecurrenceInfo recurrence = getRecurrenceInfo(); if (recurrence != null) { Debug.logWarning("Persisted Job [" + getJobId() + "] references a RecurrenceInfo, recommend using TemporalExpression instead", module); currentRecurrenceCount = recurrence.getCurrentCount(); expr = RecurrenceInfo.toTemporalExpression(recurrence); } if (expr == null && UtilValidate.isNotEmpty(jobValue.getString("tempExprId"))) { try { expr = TemporalExpressionWorker.getTemporalExpression(this.delegator, jobValue.getString("tempExprId")); } catch (GenericEntityException e) { throw new RuntimeException(e.getMessage()); } } if (jobValue.get("maxRecurrenceCount") != null) { maxRecurrenceCount = jobValue.getLong("maxRecurrenceCount").longValue(); } if (jobValue.get("currentRecurrenceCount") != null) { currentRecurrenceCount = jobValue.getLong("currentRecurrenceCount").longValue(); } if (maxRecurrenceCount != -1) { currentRecurrenceCount++; jobValue.set("currentRecurrenceCount", currentRecurrenceCount); } try { if (expr != null && (maxRecurrenceCount == -1 || currentRecurrenceCount <= maxRecurrenceCount)) { if (recurrence != null) { recurrence.incrementCurrentCount(); } Calendar next = expr.next(Calendar.getInstance()); if (next != null) { createRecurrence(next.getTimeInMillis(), false); } } } catch (GenericEntityException e) { throw new InvalidJobException(e); } if (Debug.infoOn()) Debug.logInfo("Job [" + getJobName() + "] Id [" + getJobId() + "] -- Next runtime: " + new Date(nextRecurrence), module); } private void createRecurrence(long next, boolean isRetryOnFailure) throws GenericEntityException { if (Debug.verboseOn()) Debug.logVerbose("Next runtime returned: " + next, module); if (next > startTime) { String pJobId = jobValue.getString("parentJobId"); if (pJobId == null) { pJobId = jobValue.getString("jobId"); } GenericValue newJob = GenericValue.create(jobValue); newJob.remove("jobId"); newJob.set("previousJobId", jobValue.getString("jobId")); newJob.set("parentJobId", pJobId); newJob.set("statusId", "SERVICE_PENDING"); newJob.set("startDateTime", null); newJob.set("runByInstanceId", null); newJob.set("runTime", new java.sql.Timestamp(next)); if (isRetryOnFailure) { newJob.set("currentRetryCount", new Long(currentRetryCount + 1)); } else { newJob.set("currentRetryCount", new Long(0)); } nextRecurrence = next; delegator.createSetNextSeqId(newJob); if (Debug.verboseOn()) Debug.logVerbose("Created next job entry: " + newJob, module); } } @Override protected void finish(Map<String, Object> result) throws InvalidJobException { super.finish(result); // set the finish date jobValue.set("statusId", "SERVICE_FINISHED"); jobValue.set("finishDateTime", UtilDateTime.nowTimestamp()); String jobResult = null; if (ServiceUtil.isError(result)) { jobResult = StringUtils.substring(ServiceUtil.getErrorMessage(result), 0, 255); } else { jobResult = StringUtils.substring(ServiceUtil.makeSuccessMessage(result, "", "", "", ""), 0, 255); } if (UtilValidate.isNotEmpty(jobResult)) { jobValue.set("jobResult", jobResult); } try { jobValue.store(); } catch (GenericEntityException e) { Debug.logError(e, "Cannot update the job [" + getJobId() + "] sandbox", module); } } @Override protected void failed(Throwable t) throws InvalidJobException { super.failed(t); // if the job has not been re-scheduled; we need to re-schedule and run again if (nextRecurrence == -1) { if (this.canRetry()) { // create a recurrence Calendar cal = Calendar.getInstance(); try { cal.add(Calendar.MINUTE, ServiceConfigUtil.getServiceEngine().getThreadPool().getFailedRetryMin()); } catch (GenericConfigException e) { Debug.logWarning(e, "Unable to get retry minutes for job [" + getJobId() + "], defaulting to now: ", module); } long next = cal.getTimeInMillis(); try { createRecurrence(next, true); } catch (GenericEntityException e) { Debug.logError(e, "Unable to re-schedule job [" + getJobId() + "]: ", module); } Debug.logInfo("Persisted Job [" + getJobId() + "] Failed. Re-Scheduling : " + next, module); } else { Debug.logWarning("Persisted Job [" + getJobId() + "] Failed. Max Retry Hit, not re-scheduling", module); } } // set the failed status jobValue.set("statusId", "SERVICE_FAILED"); jobValue.set("finishDateTime", UtilDateTime.nowTimestamp()); jobValue.set("jobResult", StringUtils.substring(t.getMessage(), 0, 255)); try { jobValue.store(); } catch (GenericEntityException e) { Debug.logError(e, "Cannot update the JobSandbox entity", module); } } @Override protected String getServiceName() { if (jobValue == null || jobValue.get("serviceName") == null) { return null; } return jobValue.getString("serviceName"); } @Override protected Map<String, Object> getContext() throws InvalidJobException { Map<String, Object> context = null; try { if (UtilValidate.isNotEmpty(jobValue.getString("runtimeDataId"))) { GenericValue contextObj = jobValue.getRelatedOne("RuntimeData", false); if (contextObj != null) { context = UtilGenerics.checkMap( XmlSerializer.deserialize(contextObj.getString("runtimeInfo"), delegator), String.class, Object.class); } } if (context == null) { context = new HashMap<String, Object>(); } // check the runAsUser if (UtilValidate.isNotEmpty(jobValue.getString("runAsUser"))) { context.put("userLogin", ServiceUtil.getUserLogin(dctx, context, jobValue.getString("runAsUser"))); } } catch (GenericEntityException e) { Debug.logError(e, "PersistedServiceJob.getContext(): Entity Exception", module); } catch (SerializeException e) { Debug.logError(e, "PersistedServiceJob.getContext(): Serialize Exception", module); } catch (ParserConfigurationException e) { Debug.logError(e, "PersistedServiceJob.getContext(): Parse Exception", module); } catch (SAXException e) { Debug.logError(e, "PersistedServiceJob.getContext(): SAXException", module); } catch (IOException e) { Debug.logError(e, "PersistedServiceJob.getContext(): IOException", module); } if (context == null) { Debug.logError("Job context is null", module); } return context; } // returns the number of current retries private long getRetries(Delegator delegator) { String pJobId = jobValue.getString("parentJobId"); if (pJobId == null) { return 0; } long count = 0; try { count = EntityQuery.use(delegator).from("JobSandbox") .where("parentJobId", pJobId, "statusId", "SERVICE_FAILED").queryCount(); } catch (GenericEntityException e) { Debug.logError(e, "Exception thrown while counting retries: ", module); } return count + 1; // add one for the parent } private boolean canRetry() { if (maxRetry == -1) { return true; } return currentRetryCount < maxRetry; } private RecurrenceInfo getRecurrenceInfo() { try { if (UtilValidate.isNotEmpty(jobValue.getString("recurrenceInfoId"))) { GenericValue ri = jobValue.getRelatedOne("RecurrenceInfo", false); if (ri != null) { return new RecurrenceInfo(ri); } } } catch (GenericEntityException e) { Debug.logError(e, "Problem getting RecurrenceInfo entity from JobSandbox", module); } catch (RecurrenceInfoException re) { Debug.logError(re, "Problem creating RecurrenceInfo instance: " + re.getMessage(), module); } return null; } @Override public void deQueue() throws InvalidJobException { if (currentState != State.QUEUED) { throw new InvalidJobException("Illegal state change"); } currentState = State.CREATED; try { jobValue.refresh(); jobValue.set("startDateTime", null); jobValue.set("runByInstanceId", null); jobValue.set("statusId", "SERVICE_PENDING"); jobValue.store(); } catch (GenericEntityException e) { throw new InvalidJobException("Unable to dequeue job [" + getJobId() + "]", e); } if (Debug.verboseOn()) { Debug.logVerbose("Job [" + getJobId() + "] not queued, rescheduling", module); } } @Override public Date getStartTime() { return new Date(startTime); } }