@Override public boolean isRunnable() { return this.getStatus() == ExecutableState.READY; }
@Override public String toString() { return Objects.toStringHelper(this).add("id", getId()).add("name", getName()).add("state", getStatus()) .toString(); } }
public void discardJob(String jobId) { AbstractExecutable job = getJob(jobId); if (job == null) { return; } if (job.getStatus().isFinalState()) { if (job.getStatus() != ExecutableState.DISCARDED) { logger.warn("The status of job " + jobId + " is " + job.getStatus().toString() + ". It's final state and cannot be transfer to be discarded!!!"); } else { logger.warn("The job " + jobId + " has been discarded."); } return; } if (job instanceof DefaultChainedExecutable) { List<AbstractExecutable> tasks = ((DefaultChainedExecutable) job).getTasks(); for (AbstractExecutable task : tasks) { if (!task.getStatus().isFinalState()) { updateJobOutput(task.getId(), ExecutableState.DISCARDED, null, null); } } } updateJobOutput(jobId, ExecutableState.DISCARDED, null, null); }
protected void waitForJobStatus(String jobId, ExecutableState state, long interval) { while (true) { AbstractExecutable job = execMgr.getJob(jobId); if (job.getStatus() == state) { break; } else { try { Thread.sleep(interval); } catch (InterruptedException e) { e.printStackTrace(); } } } }
private void releaseJobLock(AbstractExecutable executable) { if (executable instanceof DefaultChainedExecutable) { ExecutableState state = executable.getStatus(); if (state != ExecutableState.READY && state != ExecutableState.RUNNING) { if (jobWithLocks.contains(executable.getId())) { logger.info( executable.toString() + " will release the lock for the job: " + executable.getId()); jobLock.unlock(getLockPath(executable.getId())); jobWithLocks.remove(executable.getId()); } } } } }
public void resumeJob(String jobId) { AbstractExecutable job = getJob(jobId); if (job == null) { return; } Map<String, String> info = null; if (job instanceof DefaultChainedExecutable) { List<AbstractExecutable> tasks = ((DefaultChainedExecutable) job).getTasks(); for (AbstractExecutable task : tasks) { if (task.getStatus() == ExecutableState.ERROR || task.getStatus() == ExecutableState.STOPPED) { updateJobOutput(task.getId(), ExecutableState.READY, null, null); break; } } final long endTime = job.getEndTime(); if (endTime != 0) { long interruptTime = System.currentTimeMillis() - endTime + job.getInterruptTime(); info = Maps.newHashMap(getJobOutput(jobId).getInfo()); info.put(AbstractExecutable.INTERRUPT_TIME, Long.toString(interruptTime)); info.remove(AbstractExecutable.END_TIME); } } updateJobOutput(jobId, ExecutableState.READY, info, null); }
public void rollbackJob(String jobId, String stepId) { AbstractExecutable job = getJob(jobId); if (job == null) { return; } if (job instanceof DefaultChainedExecutable) { List<AbstractExecutable> tasks = ((DefaultChainedExecutable) job).getTasks(); for (AbstractExecutable task : tasks) { if (task.getId().compareTo(stepId) >= 0) { logger.debug("rollback task : " + task); updateJobOutput(task.getId(), ExecutableState.READY, Maps.<String, String> newHashMap(), ""); } } } if (job.getStatus() == ExecutableState.SUCCEED) { updateJobOutput(job.getId(), ExecutableState.READY, null, null); } }
protected void waitForJobFinish(String jobId, int maxWaitTime) { int error = 0; long start = System.currentTimeMillis(); final int errorLimit = 3; while (error < errorLimit && (System.currentTimeMillis() - start < maxWaitTime)) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } try { AbstractExecutable job = execMgr.getJob(jobId); ExecutableState status = job.getStatus(); if (status == ExecutableState.SUCCEED || status == ExecutableState.ERROR || status == ExecutableState.STOPPED || status == ExecutableState.DISCARDED) { break; } } catch (Exception ex) { logger.error("", ex); error++; } } if (error >= errorLimit) { throw new RuntimeException("too many exceptions"); } if (System.currentTimeMillis() - start >= maxWaitTime) { throw new RuntimeException("too long wait time"); } }
@Override protected void onExecuteFinished(ExecuteResult result, ExecutableContext executableContext) { long time = 0L; for (AbstractExecutable task : getTasks()) { final ExecutableState status = task.getStatus(); if (status != ExecutableState.SUCCEED) { break; } if (task instanceof MapReduceExecutable) { time += ((MapReduceExecutable) task).getMapReduceWaitTime(); } } setMapReduceWaitTime(time); super.onExecuteFinished(result, executableContext); }
protected void runningJobToError(String jobId) { while (true) { try { AbstractExecutable job = execMgr.getJob(jobId); ExecutableState status = job.getStatus(); if (status == ExecutableState.RUNNING) { scheduler.getFetcherRunner().setFetchFailed(true); break; } Thread.sleep(1000); } catch (Exception ex) { logger.error("", ex); } } } }
public void resumeRunningJobForce(String jobId) { AbstractExecutable job = getJob(jobId); if (job == null) { return; } if (job instanceof DefaultChainedExecutable) { List<AbstractExecutable> tasks = ((DefaultChainedExecutable) job).getTasks(); for (AbstractExecutable task : tasks) { if (task.getStatus() == ExecutableState.RUNNING) { updateJobOutput(task.getId(), ExecutableState.READY, null, null); break; } } } updateJobOutput(jobId, ExecutableState.READY, null, null); }
@Override public boolean isRunnable() { return this.getStatus() == ExecutableState.READY; }
protected JobInstance getCheckpointJobInstance(AbstractExecutable job) { Message msg = MsgPicker.getMsg(); if (job == null) { return null; } if (!(job instanceof CheckpointExecutable)) { throw new BadRequestException(String.format(Locale.ROOT, msg.getILLEGAL_JOB_TYPE(), job.getId())); } CheckpointExecutable checkpointExecutable = (CheckpointExecutable) job; Output output = checkpointExecutable.getOutput(); final JobInstance result = new JobInstance(); result.setName(job.getName()); result.setRelatedCube(CubingExecutableUtil.getCubeName(job.getParams())); result.setDisplayCubeName(CubingExecutableUtil.getCubeName(job.getParams())); result.setLastModified(job.getLastModified()); result.setSubmitter(job.getSubmitter()); result.setUuid(job.getId()); result.setType(CubeBuildTypeEnum.CHECKPOINT); result.setStatus(JobInfoConverter.parseToJobStatus(job.getStatus())); result.setBuildInstance(AbstractExecutable.getBuildInstance(output)); result.setDuration(job.getDuration() / 1000); for (int i = 0; i < checkpointExecutable.getTasks().size(); ++i) { AbstractExecutable task = checkpointExecutable.getTasks().get(i); result.addStep(JobInfoConverter.parseToJobStep(task, i, getExecutableManager().getOutput(task.getId()))); } return result; }
@Test public void test() throws Exception { assertNotNull(service); // all existing are broken jobs List<AbstractExecutable> existing = service.getAllExecutables(); for (AbstractExecutable exec : existing) { assertEquals("BrokenExecutable", exec.getClass().getSimpleName()); assertEquals(ExecutableState.DISCARDED, exec.getStatus()); } BaseTestExecutable executable = new SucceedTestExecutable(); executable.setParam("test1", "test1"); executable.setParam("test2", "test2"); executable.setParam("test3", "test3"); service.addJob(executable); List<AbstractExecutable> result = service.getAllExecutables(); assertEquals(existing.size() + 1, result.size()); AbstractExecutable another = service.getJob(executable.getId()); assertJobEqual(executable, another); service.updateJobOutput(executable.getId(), ExecutableState.RUNNING, null, "test output"); assertJobEqual(executable, service.getJob(executable.getId())); }
@Override public String toString() { return Objects.toStringHelper(this).add("id", getId()).add("name", getName()).add("state", getStatus()).toString(); } }
result.setUuid(cubeJob.getId()); result.setType(CubeBuildTypeEnum.BUILD); result.setStatus(JobInfoConverter.parseToJobStatus(job.getStatus())); result.setMrWaiting(cubeJob.getMapReduceWaitTime() / 1000); result.setBuildInstance(AbstractExecutable.getBuildInstance(output));
protected void waitForJob(String jobId) { while (true) { AbstractExecutable job = jobService.getJob(jobId); if (job.getStatus() == ExecutableState.SUCCEED || job.getStatus() == ExecutableState.ERROR) { break; } else { try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } } } }
protected void waitForJobStatus(String jobId, ExecutableState state, long interval) { while (true) { AbstractExecutable job = jobService.getJob(jobId); if (job.getStatus() == state) { break; } else { try { Thread.sleep(interval); } catch (InterruptedException e) { e.printStackTrace(); } } } }
public void resumeJob(String jobId) { AbstractExecutable job = getJob(jobId); if (job == null) { return; } updateJobOutput(jobId, ExecutableState.READY, null, null); if (job instanceof DefaultChainedExecutable) { List<AbstractExecutable> tasks = ((DefaultChainedExecutable) job).getTasks(); for (AbstractExecutable task : tasks) { if (task.getStatus() == ExecutableState.ERROR) { updateJobOutput(task.getId(), ExecutableState.READY, null, null); break; } } } }
public void discardJob(String jobId) { AbstractExecutable job = getJob(jobId); if (job instanceof DefaultChainedExecutable) { List<AbstractExecutable> tasks = ((DefaultChainedExecutable) job).getTasks(); for (AbstractExecutable task : tasks) { if (!task.getStatus().isFinalState()) { updateJobOutput(task.getId(), ExecutableState.DISCARDED, null, null); } } } updateJobOutput(jobId, ExecutableState.DISCARDED, null, null); }