| /******************************************************************************* |
| * 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.ArrayList; |
| import java.util.Collections; |
| import java.util.Date; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.concurrent.ConcurrentHashMap; |
| import java.util.concurrent.RejectedExecutionException; |
| |
| import org.apache.ofbiz.base.config.GenericConfigException; |
| import org.apache.ofbiz.base.util.Assert; |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.UtilDateTime; |
| import org.apache.ofbiz.base.util.UtilMisc; |
| import org.apache.ofbiz.base.util.UtilProperties; |
| 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.condition.EntityCondition; |
| import org.apache.ofbiz.entity.condition.EntityExpr; |
| import org.apache.ofbiz.entity.condition.EntityJoinOperator; |
| import org.apache.ofbiz.entity.condition.EntityOperator; |
| import org.apache.ofbiz.entity.serialize.SerializeException; |
| import org.apache.ofbiz.entity.serialize.XmlSerializer; |
| import org.apache.ofbiz.entity.transaction.TransactionUtil; |
| import org.apache.ofbiz.entity.util.EntityListIterator; |
| import org.apache.ofbiz.entity.util.EntityQuery; |
| import org.apache.ofbiz.service.DispatchContext; |
| import org.apache.ofbiz.service.LocalDispatcher; |
| import org.apache.ofbiz.service.ServiceContainer; |
| import org.apache.ofbiz.service.calendar.RecurrenceInfo; |
| import org.apache.ofbiz.service.calendar.RecurrenceInfoException; |
| import org.apache.ofbiz.service.config.ServiceConfigUtil; |
| import org.apache.ofbiz.service.config.model.RunFromPool; |
| |
| import com.ibm.icu.util.Calendar; |
| |
| /** |
| * Job manager. The job manager queues and manages jobs. Client code can queue a job to be run immediately |
| * by calling the {@link #runJob(Job)} method, or schedule a job to be run later by calling the |
| * {@link #schedule(String, String, String, Map, long, int, int, int, long, int)} method. |
| * Scheduled jobs are persisted in the JobSandbox entity. |
| * <p>A scheduled job's start time is an approximation - the actual start time will depend |
| * on the job manager/job poller configuration (poll interval) and the load on the server. |
| * Scheduled jobs might be rescheduled if the server is busy. Therefore, applications |
| * requiring a precise job start time should use a different mechanism to schedule the job.</p> |
| */ |
| public final class JobManager { |
| |
| public static final String module = JobManager.class.getName(); |
| public static final String instanceId = UtilProperties.getPropertyValue("general", "unique.instanceId", "ofbiz0"); |
| private static final ConcurrentHashMap<String, JobManager> registeredManagers = new ConcurrentHashMap<String, JobManager>(); |
| private static boolean isShutDown = false; |
| |
| private static void assertIsRunning() { |
| if (isShutDown) { |
| throw new IllegalStateException("OFBiz shutting down"); |
| } |
| } |
| |
| /** |
| * Returns a <code>JobManager</code> instance. |
| * @param delegator |
| * @param enablePoller Enables polling of the JobSandbox entity. |
| * @throws IllegalStateException if the Job Manager is shut down. |
| */ |
| public static JobManager getInstance(Delegator delegator, boolean enablePoller) { |
| assertIsRunning(); |
| Assert.notNull("delegator", delegator); |
| JobManager jm = registeredManagers.get(delegator.getDelegatorName()); |
| if (jm == null) { |
| jm = new JobManager(delegator); |
| registeredManagers.putIfAbsent(delegator.getDelegatorName(), jm); |
| jm = registeredManagers.get(delegator.getDelegatorName()); |
| if (enablePoller) { |
| JobPoller.registerJobManager(jm); |
| } |
| } |
| return jm; |
| } |
| |
| /** |
| * Shuts down all job managers. This method is called when OFBiz shuts down. |
| */ |
| public static void shutDown() { |
| isShutDown = true; |
| JobPoller.getInstance().stop(); |
| } |
| |
| private final Delegator delegator; |
| private boolean crashedJobsReloaded = false; |
| |
| private JobManager(Delegator delegator) { |
| this.delegator = delegator; |
| } |
| |
| /** Returns the Delegator. */ |
| public Delegator getDelegator() { |
| return this.delegator; |
| } |
| |
| /** Returns the LocalDispatcher. */ |
| public LocalDispatcher getDispatcher() { |
| LocalDispatcher thisDispatcher = ServiceContainer.getLocalDispatcher(delegator.getDelegatorName(), delegator); |
| return thisDispatcher; |
| } |
| |
| /** |
| * Get a List of each threads current state. |
| * |
| * @return List containing a Map of each thread's state. |
| */ |
| public Map<String, Object> getPoolState() { |
| return JobPoller.getInstance().getPoolState(); |
| } |
| |
| /** |
| * Return true if the jobManager can run job. |
| * |
| * @return boolean. |
| */ |
| public boolean isAvailable() { |
| try { |
| //check if a lock is enable for the period on entity JobManagerLock |
| EntityCondition condition = EntityCondition.makeCondition(UtilMisc.toList( |
| EntityCondition.makeConditionDate("fromDate", "thruDate"), |
| EntityCondition.makeCondition(UtilMisc.toList( |
| EntityCondition.makeCondition("instanceId", instanceId), |
| EntityCondition.makeCondition("instanceId", "_NA_")) |
| , EntityJoinOperator.OR) |
| ), EntityJoinOperator.AND); |
| return delegator.findCountByCondition("JobManagerLock", condition, null, null) == 0; |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, "Exception thrown while check lock on JobManager : " + instanceId, module); |
| return false; |
| } |
| } |
| |
| private static List<String> getRunPools() throws GenericConfigException { |
| List<RunFromPool> runFromPools = ServiceConfigUtil.getServiceEngine().getThreadPool().getRunFromPools(); |
| List<String> readPools = new ArrayList<String>(runFromPools.size()); |
| for (RunFromPool runFromPool : runFromPools) { |
| readPools.add(runFromPool.getName()); |
| } |
| return readPools; |
| } |
| |
| /** |
| * Scans the JobSandbox entity and returns a list of jobs that are due to run. |
| * Returns an empty list if there are no jobs due to run. |
| * This method is called by the {@link JobPoller} polling thread. |
| */ |
| protected List<Job> poll(int limit) { |
| assertIsRunning(); |
| // The rest of this method logs exceptions and does not throw them. |
| // The idea is to keep the JobPoller working even when a database |
| // connection is not available (possible on a saturated server). |
| DispatchContext dctx = getDispatcher().getDispatchContext(); |
| if (dctx == null) { |
| Debug.logWarning("Unable to locate DispatchContext object; not running job!", module); |
| return Collections.emptyList(); |
| } |
| // basic query |
| List<EntityExpr> expressions = UtilMisc.toList(EntityCondition.makeCondition("runTime", EntityOperator.LESS_THAN_EQUAL_TO, UtilDateTime.nowTimestamp()), |
| EntityCondition.makeCondition("startDateTime", EntityOperator.EQUALS, null), |
| EntityCondition.makeCondition("cancelDateTime", EntityOperator.EQUALS, null), |
| EntityCondition.makeCondition("runByInstanceId", EntityOperator.EQUALS, null)); |
| // limit to just defined pools |
| List<String> pools = null; |
| try { |
| pools = getRunPools(); |
| } catch (GenericConfigException e) { |
| Debug.logWarning(e, "Unable to get run pools - not running job: ", module); |
| return Collections.emptyList(); |
| } |
| List<EntityExpr> poolsExpr = UtilMisc.toList(EntityCondition.makeCondition("poolId", EntityOperator.EQUALS, null)); |
| if (!pools.isEmpty()) { |
| for (String poolName : pools) { |
| poolsExpr.add(EntityCondition.makeCondition("poolId", EntityOperator.EQUALS, poolName)); |
| } |
| } |
| List<Job> poll = new ArrayList<Job>(limit); |
| // make the conditions |
| EntityCondition baseCondition = EntityCondition.makeCondition(expressions); |
| EntityCondition poolCondition = EntityCondition.makeCondition(poolsExpr, EntityOperator.OR); |
| EntityCondition mainCondition = EntityCondition.makeCondition(UtilMisc.toList(baseCondition, poolCondition)); |
| EntityListIterator jobsIterator = null; |
| boolean beganTransaction = false; |
| try { |
| beganTransaction = TransactionUtil.begin(); |
| if (!beganTransaction) { |
| Debug.logWarning("Unable to poll JobSandbox for jobs; unable to begin transaction.", module); |
| return poll; |
| } |
| jobsIterator = EntityQuery.use(delegator).from("JobSandbox").where(mainCondition).orderBy("runTime").queryIterator(); |
| GenericValue jobValue = jobsIterator.next(); |
| while (jobValue != null) { |
| // Claim ownership of this value. Using storeByCondition to avoid a race condition. |
| List<EntityExpr> updateExpression = UtilMisc.toList(EntityCondition.makeCondition("jobId", EntityOperator.EQUALS, jobValue.get("jobId")), EntityCondition.makeCondition("runByInstanceId", EntityOperator.EQUALS, null)); |
| int rowsUpdated = delegator.storeByCondition("JobSandbox", UtilMisc.toMap("runByInstanceId", instanceId), EntityCondition.makeCondition(updateExpression)); |
| if (rowsUpdated == 1) { |
| poll.add(new PersistedServiceJob(dctx, jobValue, null)); |
| if (poll.size() == limit) { |
| break; |
| } |
| } |
| jobValue = jobsIterator.next(); |
| } |
| TransactionUtil.commit(beganTransaction); |
| } catch (Throwable t) { |
| String errMsg = "Exception thrown while polling JobSandbox: "; |
| try { |
| TransactionUtil.rollback(beganTransaction, errMsg, t); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, "Exception thrown while rolling back transaction: ", module); |
| } |
| Debug.logWarning(t, errMsg, module); |
| return Collections.emptyList(); |
| } finally { |
| if (jobsIterator != null) { |
| try { |
| jobsIterator.close(); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, module); |
| } |
| } |
| } |
| if (poll.isEmpty()) { |
| // No jobs to run, see if there are any jobs to purge |
| Calendar cal = Calendar.getInstance(); |
| try { |
| int daysToKeep = ServiceConfigUtil.getServiceEngine().getThreadPool().getPurgeJobDays(); |
| cal.add(Calendar.DAY_OF_YEAR, -daysToKeep); |
| } catch (GenericConfigException e) { |
| Debug.logWarning(e, "Unable to get purge job days: ", module); |
| return Collections.emptyList(); |
| } |
| Timestamp purgeTime = new Timestamp(cal.getTimeInMillis()); |
| List<EntityExpr> finExp = UtilMisc.toList(EntityCondition.makeCondition("finishDateTime", EntityOperator.NOT_EQUAL, null), EntityCondition.makeCondition("finishDateTime", EntityOperator.LESS_THAN, purgeTime)); |
| List<EntityExpr> canExp = UtilMisc.toList(EntityCondition.makeCondition("cancelDateTime", EntityOperator.NOT_EQUAL, null), EntityCondition.makeCondition("cancelDateTime", EntityOperator.LESS_THAN, purgeTime)); |
| EntityCondition doneCond = EntityCondition.makeCondition(UtilMisc.toList(EntityCondition.makeCondition(canExp), EntityCondition.makeCondition(finExp)), EntityOperator.OR); |
| mainCondition = EntityCondition.makeCondition(UtilMisc.toList(EntityCondition.makeCondition("runByInstanceId", instanceId), doneCond)); |
| beganTransaction = false; |
| jobsIterator = null; |
| try { |
| beganTransaction = TransactionUtil.begin(); |
| if (!beganTransaction) { |
| Debug.logWarning("Unable to poll JobSandbox for jobs; unable to begin transaction.", module); |
| return Collections.emptyList(); |
| } |
| jobsIterator = EntityQuery.use(delegator).from("JobSandbox").where(mainCondition).orderBy("jobId").queryIterator(); |
| GenericValue jobValue = jobsIterator.next(); |
| while (jobValue != null) { |
| poll.add(new PurgeJob(jobValue)); |
| if (poll.size() == limit) { |
| break; |
| } |
| jobValue = jobsIterator.next(); |
| } |
| TransactionUtil.commit(beganTransaction); |
| } catch (Throwable t) { |
| String errMsg = "Exception thrown while polling JobSandbox: "; |
| try { |
| TransactionUtil.rollback(beganTransaction, errMsg, t); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, "Exception thrown while rolling back transaction: ", module); |
| } |
| Debug.logWarning(t, errMsg, module); |
| return Collections.emptyList(); |
| } finally { |
| if (jobsIterator != null) { |
| try { |
| jobsIterator.close(); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, module); |
| } |
| } |
| } |
| } |
| return poll; |
| } |
| |
| public synchronized void reloadCrashedJobs() { |
| assertIsRunning(); |
| if (crashedJobsReloaded) { |
| return; |
| } |
| List<GenericValue> crashed = null; |
| List<EntityExpr> statusExprList = UtilMisc.toList(EntityCondition.makeCondition("statusId", EntityOperator.EQUALS, "SERVICE_PENDING"), |
| EntityCondition.makeCondition("statusId", EntityOperator.EQUALS, "SERVICE_QUEUED"), |
| EntityCondition.makeCondition("statusId", EntityOperator.EQUALS, "SERVICE_RUNNING")); |
| EntityCondition statusCondition = EntityCondition.makeCondition(statusExprList, EntityOperator.OR); |
| EntityCondition mainCondition = EntityCondition.makeCondition(UtilMisc.toList(EntityCondition.makeCondition("runByInstanceId", instanceId), statusCondition)); |
| try { |
| crashed = EntityQuery.use(delegator).from("JobSandbox").where(mainCondition).orderBy("startDateTime").queryList(); |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, "Unable to load crashed jobs", module); |
| } |
| if (UtilValidate.isNotEmpty(crashed)) { |
| int rescheduled = 0; |
| Timestamp now = UtilDateTime.nowTimestamp(); |
| for (GenericValue job : crashed) { |
| try { |
| if (Debug.infoOn()) Debug.logInfo("Scheduling Job : " + job, module); |
| String pJobId = job.getString("parentJobId"); |
| if (pJobId == null) { |
| pJobId = job.getString("jobId"); |
| } |
| GenericValue newJob = GenericValue.create(job); |
| newJob.set("statusId", "SERVICE_PENDING"); |
| newJob.set("runTime", now); |
| newJob.set("previousJobId", job.getString("jobId")); |
| newJob.set("parentJobId", pJobId); |
| newJob.set("startDateTime", null); |
| newJob.set("runByInstanceId", null); |
| //don't set a recurrent schedule on the new job, run it just one time |
| newJob.set("tempExprId", null); |
| newJob.set("recurrenceInfoId", null); |
| delegator.createSetNextSeqId(newJob); |
| // set the cancel time on the old job to the same as the re-schedule time |
| job.set("statusId", "SERVICE_CRASHED"); |
| job.set("cancelDateTime", now); |
| delegator.store(job); |
| rescheduled++; |
| } catch (GenericEntityException e) { |
| Debug.logWarning(e, module); |
| } |
| } |
| if (Debug.infoOn()) |
| Debug.logInfo("-- " + rescheduled + " jobs re-scheduled", module); |
| } else { |
| if (Debug.infoOn()) |
| Debug.logInfo("No crashed jobs to re-schedule", module); |
| } |
| crashedJobsReloaded = true; |
| } |
| |
| /** Queues a Job to run now. |
| * @throws IllegalStateException if the Job Manager is shut down. |
| * @throws RejectedExecutionException if the poller is stopped. |
| */ |
| public void runJob(Job job) throws JobManagerException { |
| assertIsRunning(); |
| if (job.isValid()) { |
| JobPoller.getInstance().queueNow(job); |
| } |
| } |
| |
| /** |
| * Schedule a job to start at a specific time with specific recurrence info |
| * |
| * @param serviceName |
| * The name of the service to invoke |
| *@param context |
| * The context for the service |
| *@param startTime |
| * The time in milliseconds the service should run |
| *@param frequency |
| * The frequency of the recurrence (HOURLY,DAILY,MONTHLY,etc) |
| *@param interval |
| * The interval of the frequency recurrence |
| *@param count |
| * The number of times to repeat |
| */ |
| public void schedule(String serviceName, Map<String, ? extends Object> context, long startTime, int frequency, int interval, int count) throws JobManagerException { |
| schedule(serviceName, context, startTime, frequency, interval, count, 0); |
| } |
| |
| /** |
| * Schedule a job to start at a specific time with specific recurrence info |
| * |
| * @param serviceName |
| * The name of the service to invoke |
| *@param context |
| * The context for the service |
| *@param startTime |
| * The time in milliseconds the service should run |
| *@param frequency |
| * The frequency of the recurrence (HOURLY,DAILY,MONTHLY,etc) |
| *@param interval |
| * The interval of the frequency recurrence |
| *@param count |
| * The number of times to repeat |
| *@param endTime |
| * The time in milliseconds the service should expire |
| */ |
| public void schedule(String serviceName, Map<String, ? extends Object> context, long startTime, int frequency, int interval, int count, long endTime) throws JobManagerException { |
| schedule(null, serviceName, context, startTime, frequency, interval, count, endTime); |
| } |
| |
| /** |
| * Schedule a job to start at a specific time with specific recurrence info |
| * |
| * @param serviceName |
| * The name of the service to invoke |
| *@param context |
| * The context for the service |
| *@param startTime |
| * The time in milliseconds the service should run |
| *@param frequency |
| * The frequency of the recurrence (HOURLY,DAILY,MONTHLY,etc) |
| *@param interval |
| * The interval of the frequency recurrence |
| *@param endTime |
| * The time in milliseconds the service should expire |
| */ |
| public void schedule(String serviceName, Map<String, ? extends Object> context, long startTime, int frequency, int interval, long endTime) throws JobManagerException { |
| schedule(serviceName, context, startTime, frequency, interval, -1, endTime); |
| } |
| |
| /** |
| * Schedule a job to start at a specific time with specific recurrence info |
| * |
| * @param poolName |
| * The name of the pool to run the service from |
| *@param serviceName |
| * The name of the service to invoke |
| *@param context |
| * The context for the service |
| *@param startTime |
| * The time in milliseconds the service should run |
| *@param frequency |
| * The frequency of the recurrence (HOURLY,DAILY,MONTHLY,etc) |
| *@param interval |
| * The interval of the frequency recurrence |
| *@param count |
| * The number of times to repeat |
| *@param endTime |
| * The time in milliseconds the service should expire |
| */ |
| public void schedule(String poolName, String serviceName, Map<String, ? extends Object> context, long startTime, int frequency, |
| int interval, int count, long endTime) throws JobManagerException { |
| schedule(null, null, serviceName, context, startTime, frequency, interval, count, endTime, -1); |
| } |
| |
| /** |
| * Schedule a job to start at a specific time with specific recurrence info |
| * |
| * @param poolName |
| * The name of the pool to run the service from |
| *@param serviceName |
| * The name of the service to invoke |
| *@param dataId |
| * The persisted context (RuntimeData.runtimeDataId) |
| *@param startTime |
| * The time in milliseconds the service should run |
| */ |
| public void schedule(String poolName, String serviceName, String dataId, long startTime) throws JobManagerException { |
| schedule(null, poolName, serviceName, dataId, startTime, -1, 0, 1, 0, -1); |
| } |
| |
| /** |
| * Schedule a job to start at a specific time with specific recurrence info |
| * |
| * @param jobName |
| * The name of the job |
| *@param poolName |
| * The name of the pool to run the service from |
| *@param serviceName |
| * The name of the service to invoke |
| *@param context |
| * The context for the service |
| *@param startTime |
| * The time in milliseconds the service should run |
| *@param frequency |
| * The frequency of the recurrence (HOURLY,DAILY,MONTHLY,etc) |
| *@param interval |
| * The interval of the frequency recurrence |
| *@param count |
| * The number of times to repeat |
| *@param endTime |
| * The time in milliseconds the service should expire |
| *@param maxRetry |
| * The max number of retries on failure (-1 for no max) |
| */ |
| public void schedule(String jobName, String poolName, String serviceName, Map<String, ? extends Object> context, long startTime, |
| int frequency, int interval, int count, long endTime, int maxRetry) throws JobManagerException { |
| // persist the context |
| String dataId = null; |
| try { |
| GenericValue runtimeData = delegator.makeValue("RuntimeData"); |
| runtimeData.set("runtimeInfo", XmlSerializer.serialize(context)); |
| runtimeData = delegator.createSetNextSeqId(runtimeData); |
| dataId = runtimeData.getString("runtimeDataId"); |
| } catch (GenericEntityException ee) { |
| throw new JobManagerException(ee.getMessage(), ee); |
| } catch (SerializeException se) { |
| throw new JobManagerException(se.getMessage(), se); |
| } catch (IOException ioe) { |
| throw new JobManagerException(ioe.getMessage(), ioe); |
| } |
| // schedule the job |
| schedule(jobName, poolName, serviceName, dataId, startTime, frequency, interval, count, endTime, maxRetry); |
| } |
| |
| /** |
| * Schedule a job to start at a specific time with specific recurrence info |
| * |
| * @param jobName |
| * The name of the job |
| *@param poolName |
| * The name of the pool to run the service from |
| *@param serviceName |
| * The name of the service to invoke |
| *@param dataId |
| * The persisted context (RuntimeData.runtimeDataId) |
| *@param startTime |
| * The time in milliseconds the service should run |
| *@param frequency |
| * The frequency of the recurrence (HOURLY,DAILY,MONTHLY,etc) |
| *@param interval |
| * The interval of the frequency recurrence |
| *@param count |
| * The number of times to repeat |
| *@param endTime |
| * The time in milliseconds the service should expire |
| *@param maxRetry |
| * The max number of retries on failure (-1 for no max) |
| * @throws IllegalStateException if the Job Manager is shut down. |
| */ |
| public void schedule(String jobName, String poolName, String serviceName, String dataId, long startTime, int frequency, int interval, |
| int count, long endTime, int maxRetry) throws JobManagerException { |
| assertIsRunning(); |
| // create the recurrence |
| String infoId = null; |
| if (frequency > -1 && count != 0) { |
| try { |
| RecurrenceInfo info = RecurrenceInfo.makeInfo(delegator, startTime, frequency, interval, count); |
| infoId = info.primaryKey(); |
| } catch (RecurrenceInfoException e) { |
| throw new JobManagerException(e.getMessage(), e); |
| } |
| } |
| // set the persisted fields |
| if (UtilValidate.isEmpty(jobName)) { |
| jobName = Long.toString((new Date().getTime())); |
| } |
| Map<String, Object> jFields = UtilMisc.<String, Object> toMap("jobName", jobName, "runTime", new java.sql.Timestamp(startTime), |
| "serviceName", serviceName, "statusId", "SERVICE_PENDING", "recurrenceInfoId", infoId, "runtimeDataId", dataId); |
| // set the pool ID |
| if (UtilValidate.isNotEmpty(poolName)) { |
| jFields.put("poolId", poolName); |
| } else { |
| try { |
| jFields.put("poolId", ServiceConfigUtil.getServiceEngine().getThreadPool().getSendToPool()); |
| } catch (GenericConfigException e) { |
| throw new JobManagerException(e.getMessage(), e); |
| } |
| } |
| // set the loader name |
| jFields.put("loaderName", delegator.getDelegatorName()); |
| // set the max retry |
| jFields.put("maxRetry", Long.valueOf(maxRetry)); |
| jFields.put("currentRetryCount", new Long(0)); |
| // create the value and store |
| GenericValue jobV; |
| try { |
| jobV = delegator.makeValue("JobSandbox", jFields); |
| delegator.createSetNextSeqId(jobV); |
| } catch (GenericEntityException e) { |
| throw new JobManagerException(e.getMessage(), e); |
| } |
| } |
| } |
