private boolean checkSkip(String cubingJobId) { if (cubingJobId == null) return false; ExecutableManager execMgr = ExecutableManager.getInstance(KylinConfig.getInstanceFromEnv()); CubingJob cubingJob = (CubingJob) execMgr.getJob(cubingJobId); skipped = cubingJob.isInMemCubing() == false; return skipped; }
private void resumeAllRunningJobs() { for (final String id : executableManager.getAllJobIds()) { final Output output = executableManager.getOutput(id); AbstractExecutable executable = executableManager.getJob(id); if (output.getState() == ExecutableState.RUNNING && executable instanceof DefaultChainedExecutable) { try { if (!jobLock.isLocked(getLockPath(executable.getId()))) { executableManager.resumeRunningJobForce(executable.getId()); fetcherPool.schedule(fetcher, 0, TimeUnit.SECONDS); } } catch (Exception e) { logger.error("resume the job " + id + " fail in server: " + serverName, e); } } } }
public void addJobInfo(String id, String key, String value) { Map<String, String> info = Maps.newHashMap(); info.put(key, value); addJobInfo(id, info); }
public void pauseJob(String jobId) { AbstractExecutable job = getJob(jobId); if (job == null) { return; } updateJobOutput(jobId, ExecutableState.STOPPED, null, null); }
@Test public void testIllegalState() throws Exception { logger.info("testIllegalState"); DefaultChainedExecutable job = new DefaultChainedExecutable(); BaseTestExecutable task1 = new SucceedTestExecutable(); BaseTestExecutable task2 = new RunningTestExecutable(); job.addTask(task1); job.addTask(task2); execMgr.addJob(job); ExecutableManager.getInstance(KylinConfig.getInstanceFromEnv()).updateJobOutput(task2.getId(), ExecutableState.RUNNING, null, null); waitForJobFinish(job.getId(), 10000); Assert.assertEquals(ExecutableState.ERROR, execMgr.getOutput(job.getId()).getState()); Assert.assertEquals(ExecutableState.SUCCEED, execMgr.getOutput(task1.getId()).getState()); Assert.assertEquals(ExecutableState.ERROR, execMgr.getOutput(task2.getId()).getState()); }
protected StorageCleanupJob(KylinConfig config, FileSystem defaultFs, FileSystem hbaseFs) { this.config = config; this.defaultFs = defaultFs; this.hbaseFs = hbaseFs; this.executableManager = ExecutableManager.getInstance(config); }
@Test public void testSingleTaskJob() throws Exception { logger.info("testSingleTaskJob"); DefaultChainedExecutable job = new DefaultChainedExecutable(); BaseTestExecutable task1 = new SucceedTestExecutable(); job.addTask(task1); execMgr.addJob(job); waitForJobFinish(job.getId(), 10000); Assert.assertEquals(ExecutableState.SUCCEED, execMgr.getOutput(job.getId()).getState()); Assert.assertEquals(ExecutableState.SUCCEED, execMgr.getOutput(task1.getId()).getState()); }
List<String> allJobs = executableManager.getAllJobIds(); List<String> workingJobList = new ArrayList<String>(); Map<String, String> segmentId2JobId = Maps.newHashMap(); final ExecutableState state = executableManager.getOutput(jobId).getState(); if (!state.isFinalState()) { workingJobList.add(jobId);
@Override public void onUnlock(String path, String nodeData) { String[] paths = StringUtil.split(path, "/"); String jobId = paths[paths.length - 1]; // Sync execute cache in case broadcast not available try { executableManager.syncDigestsOfJob(jobId); } catch (PersistentException e) { logger.error("Failed to sync cache of job: " + jobId + ", at server: " + serverName); } final Output output = executableManager.getOutput(jobId); if (output.getState() == ExecutableState.RUNNING) { AbstractExecutable executable = executableManager.getJob(jobId); if (executable instanceof DefaultChainedExecutable && !nodeData.equalsIgnoreCase(serverName)) { try { logger.warn(nodeData + " has released the lock for: " + jobId + " but the job still running. so " + serverName + " resume the job"); if (!jobLock.isLocked(getLockPath(jobId))) { executableManager.resumeRunningJobForce(executable.getId()); fetcherPool.schedule(fetcher, 0, TimeUnit.SECONDS); } } catch (Exception e) { logger.error("resume the job but fail in server: " + serverName, e); } } } }
@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())); }
public Output getOutput(String id) { return getExecutableManager().getOutput(id); }
Configuration conf = new Configuration(HadoopUtil.getCurrentConfiguration()); String[] jobArgs = overwriteJobConf(conf, context.getConfig(), getMapReduceParams().trim().split("\\s+")); final Map<String, String> extra = mgr.getOutput(getId()).getExtra(); if (extra.containsKey(ExecutableConstants.MR_JOB_ID)) { job = new Cluster(conf).getJob(JobID.forName(extra.get(ExecutableConstants.MR_JOB_ID))); mgr.updateJobOutput(getId(), ExecutableState.ERROR, hadoopCmdOutput.getInfo(), "killed by admin"); return new ExecuteResult(ExecuteResult.State.FAILED, "killed by admin"); setMapReduceWaitTime(waitTime); mgr.addJobInfo(getId(), hadoopCmdOutput.getInfo()); status = newStatus; if (status.isComplete()) { final Map<String, String> info = hadoopCmdOutput.getInfo(); readCounters(hadoopCmdOutput, info); mgr.addJobInfo(getId(), info);
public void calculateCardinalityIfNotPresent(String[] tables, String submitter, String prj) throws Exception { // calculate cardinality for Hive source ProjectInstance projectInstance = getProjectManager().getProject(prj); if (projectInstance == null || projectInstance.getSourceType() != ISourceAware.ID_HIVE){ return; } TableMetadataManager metaMgr = getTableManager(); ExecutableManager exeMgt = ExecutableManager.getInstance(getConfig()); for (String table : tables) { TableExtDesc tableExtDesc = metaMgr.getTableExt(table, prj); String jobID = tableExtDesc.getJodID(); if (null == jobID || ExecutableState.RUNNING != exeMgt.getOutput(jobID).getState()) { calculateCardinality(table, submitter, prj); } } }
protected void onExecuteError(Throwable exception, ExecutableContext executableContext) { if (!isDiscarded()) { getManager().addJobInfo(getId(), END_TIME, Long.toString(System.currentTimeMillis())); String output = null; if (exception != null) { final StringWriter out = new StringWriter(); exception.printStackTrace(new PrintWriter(out)); output = out.toString(); } getManager().updateJobOutput(getId(), ExecutableState.ERROR, null, output); } }
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); }
private String getSegmentIdFromJobId(String jobId) { AbstractExecutable abstractExecutable = executableManager.getJob(jobId); String segmentId = abstractExecutable.getParam("segmentId"); return segmentId; }
protected ExecuteResult doWork(ExecutableContext context) throws ExecuteException { ExecutableManager mgr = getManager(); Map<String, String> extra = mgr.getOutput(getId()).getExtra(); String sparkJobId = extra.get(ExecutableConstants.SPARK_JOB_ID); if (!StringUtils.isEmpty(sparkJobId)) { extra = mgr.getOutput(getId()).getExtra(); if (extra != null && extra.get(ExecutableConstants.SPARK_JOB_ID) != null) { killAppRetry(extra.get(ExecutableConstants.SPARK_JOB_ID)); getManager().addJobInfo(getId(), joblogInfo); return new ExecuteResult(ExecuteResult.State.SUCCEED, patternedLogger.getBufferedLog()); extra = mgr.getOutput(getId()).getExtra(); extra.put(ExecutableConstants.SPARK_JOB_ID, ""); getManager().addJobInfo(getId(), extra); return new ExecuteResult(ExecuteResult.State.ERROR, result != null ? result.getSecond() : ""); } catch (Exception e) {
@Test public void testDiscard() throws Exception { logger.info("testDiscard"); DefaultChainedExecutable job = new DefaultChainedExecutable(); SelfStopExecutable task1 = new SelfStopExecutable(); job.addTask(task1); execMgr.addJob(job); Thread.sleep(1100); // give time to launch job/task1 waitForJobStatus(job.getId(), ExecutableState.RUNNING, 500); execMgr.discardJob(job.getId()); waitForJobFinish(job.getId(), 10000); Assert.assertEquals(ExecutableState.DISCARDED, execMgr.getOutput(job.getId()).getState()); Assert.assertEquals(ExecutableState.DISCARDED, execMgr.getOutput(task1.getId()).getState()); task1.waitForDoWork(); }
protected void onExecuteStart(ExecutableContext executableContext) { Map<String, String> info = Maps.newHashMap(); info.put(START_TIME, Long.toString(System.currentTimeMillis())); getManager().updateJobOutput(getId(), ExecutableState.RUNNING, info, null); }
@Test public void testDefaultChainedExecutable() throws Exception { DefaultChainedExecutable job = new DefaultChainedExecutable(); job.addTask(new SucceedTestExecutable()); job.addTask(new SucceedTestExecutable()); service.addJob(job); assertEquals(2, job.getTasks().size()); AbstractExecutable anotherJob = service.getJob(job.getId()); assertEquals(DefaultChainedExecutable.class, anotherJob.getClass()); assertEquals(2, ((DefaultChainedExecutable) anotherJob).getTasks().size()); assertJobEqual(job, anotherJob); }