Java Session类代码示例

import org.ggf.drmaa.Session; //导入依赖的package包/类
@Override
public void execute(ServletContext servletContext, PlanBuilder planBuilder, Run run, boolean async) {
	SessionFactory sessionFactory = SessionFactory.getFactory();
	Session session = sessionFactory.getSession();
	try {
		session.init("");
		JobTemplate jobTemplate = createJobTemplate(servletContext, session, run);
		String jobId = enqueue(session, run, jobTemplate);
		if (async) {
			String status = waitForStatus(session, jobId);
			if (status != null) {
				run.addStatus(status, "", true);
			}
		}
		session.deleteJobTemplate(jobTemplate);
		session.exit();
	}
	catch (DrmaaException e) {
		throw new RuntimeException(e);
	}
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
private static JobTemplate createJobTemplate(ServletContext servletContext, Session session, Run run) throws DrmaaException {
	JobTemplate result = session.createJobTemplate();
	result.setRemoteCommand("java");
	result.setArgs(Arrays.asList(
			"-cp",
			DRMAAContextParameter.JARS_PATH.getStringValue(servletContext),
			DRMAAExecutor.class.getCanonicalName(),
			AlvisNLPContextParameter.ROOT_PROCESSING_DIR.getStringValue(servletContext),
			AlvisNLPContextParameter.RESOURCE_DIR.getStringValue(servletContext),
			AlvisNLPContextParameter.PLAN_DIR.getStringValue(servletContext),
			run.getId()
			));
	String nativeSpecification = DRMAAContextParameter.NATIVE_SPECIFICATION.getStringValue(servletContext);
	if (nativeSpecification != null && !nativeSpecification.isEmpty()) {
		result.setNativeSpecification(nativeSpecification);
	}
	return result;
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
@Override
public void cancel(Run run) {
	String jobId = run.getProperty(DRMAA_JOB_ID_PROPERTY);
	if (jobId == null) {
		return;
	}
	SessionFactory sessionFactory = SessionFactory.getFactory();
	Session session = sessionFactory.getSession();
	try {
		session.init("");
		session.control(jobId, Session.TERMINATE);
		session.exit();
	}
	catch (DrmaaException e) {
		e.printStackTrace();
	}
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
public String statustoString(int jobstatus) {
    switch (jobstatus) {
        case Session.QUEUED_ACTIVE:
            return "Job is pending";
        case Session.SYSTEM_ON_HOLD:
            return "Job is on hold by system.";
        case Session.USER_ON_HOLD:
            return "Job is on hold by user.";
        case Session.USER_SYSTEM_ON_HOLD:
            return "Job is on hold by system or user.";
        case Session.RUNNING:
            return "Job is running";
        case Session.SYSTEM_SUSPENDED:
            return "Job is suspended by system.";
        case Session.USER_SUSPENDED:
            return "Job is suspended by user.";
        case Session.USER_SYSTEM_SUSPENDED:
            return "Job is suspended by system or user.";
        case Session.DONE:
            return "Job has completed";
        case Session.FAILED:
            return "Job has failed.";
    }
    return "Job status is unknown";
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
@Override
public int getCompletedInstances() {
  int comp = 0;
  try {
    for (String job : jobs) {
      int status = session.getJobProgramStatus(job);

      //if( status == session.FAILED )
      //System.err.println( "[" + job + "] failed." );

      if (status == Session.DONE || status == Session.FAILED) {
        comp += 1;
      }
    }
  } catch (DrmaaException e) {
    return 0;
  }

  return comp;
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
@Override
public int getRunningInstances() {
  int comp = 0;
  try {
    for (String job : jobs) {
      int status = session.getJobProgramStatus(job);

      comp += 1;

      //if( status == session.FAILED )
      //System.err.println( "[" + job + "] failed." );

      if (status == Session.QUEUED_ACTIVE || status == Session.DONE || status == Session.FAILED) {
        comp -= 1;
      }
    }
  } catch (DrmaaException e) {
    return 0;
  }

  return comp;
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
@Override
public int getQueuedInstances() {
  int queued = 0;
  try {
    for (String job : jobs) {
      int status = session.getJobProgramStatus(job);

      if (status == Session.QUEUED_ACTIVE) {
        queued += 1;
      }
    }
  } catch (DrmaaException e) {
    return 0;
  }

  return queued;
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
@Override
public synchronized List<Double> getRunTimes() {
  ArrayList<Double> times = new ArrayList<>();
  long current;
  if (startTimes != null) {
    for (String jobid : startTimes.keySet()) {
      try {
        int status = session.getJobProgramStatus(jobid);
        long start = startTimes.get(jobid);
        if (status == Session.DONE || status == Session.FAILED) {
          if (!stopTimes.containsKey(jobid)) {
            stopTimes.put(jobid, System.currentTimeMillis());
          }
          current = stopTimes.get(jobid);
        } else {
          current = System.currentTimeMillis();
        }
        double diff = (current - start + 0.0) / 1000.0;
        times.add(diff);
      } catch (DrmaaException e) {
        logger.log(Level.WARNING, e.getMessage(), e);
      }
    }
  }
  return times;
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
@Override
public ImmutableMap<SimulationInputs, Simulation> runExperiments(
    Set<SimulationInputs> simulationInputsSet, List<RandomTrial> randomTrials) {
  Map<SimulationInputs, List<SimulationDrmaaJobInfo>> jobsByInput = Maps
      .newHashMap();
  List<String> allJobIds = Lists.newArrayList();
  for (SimulationInputs experiment : simulationInputsSet) {
    List<SimulationDrmaaJobInfo> jobs = makeJobs(experiment, randomTrials);
    jobsByInput.put(experiment, jobs);
    allJobIds.addAll(submitJobs(jobs));
  }
  try {
    session.synchronize(allJobIds, Session.TIMEOUT_WAIT_FOREVER, true);
  } catch (DrmaaException e) {
    throw new RuntimeException(e);
  }
  System.out.println("All jobs finished");
  ImmutableMap.Builder<SimulationInputs, Simulation> ans = ImmutableMap
      .builder();
  for (Map.Entry<SimulationInputs, List<SimulationDrmaaJobInfo>> entry : jobsByInput
      .entrySet()) {
    ans.put(entry.getKey(), mergeResults(entry.getValue(), 0));
  }
  return ans.build();
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
@Override
public void control(String jobId, int action) throws DrmaaException {
    LOGGER.log(Level.FINEST, "Control");
    // TODO implement other actions
    switch (action) {
    // case Session.SUSPEND: suspendJob(jobId); break;
    // case Session.RESUME: resumeJob(jobId); break;
    // case Session.HOLD: holdJob(jobId); break;
    // case Session.RELEASE: releaseJob(jobId); break;
    case Session.TERMINATE:
        stopJob(jobId);
        break;
    default:
        throw new InvalidJobException("Drmma Action not implemented yet" + action);
    }
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
/**
 * Add a shutdown hook that will close the DRMAA session upon program termination
 * This should be added to every main method that will use a Scheduler
 * @param drmaaSession 
 * @throws DrmaaException
 */
public static void attachShutDownHook(final Session drmaaSession) throws DrmaaException {
	Runtime.getRuntime().addShutdownHook(new Thread() {
		@Override
		public void run() {
			try {
				logger.info("Ending DRMAA session");
				drmaaSession.exit();
			} catch (DrmaaException e) {
				e.printStackTrace();
				logger.warn("DRMAA session might not be closed");
			}
		}
	});
	logger.info("Attached shutdown hook to close DRMAA session upon JVM exit.");
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
private static String enqueue(Session session, Run run, JobTemplate jobTemplate) throws DrmaaException {
	String result = session.runJob(jobTemplate);
	run.addStatus(RunStatus.QUEUED, result, false);
	run.setProperty(DRMAA_JOB_ID_PROPERTY, result);
	run.write();
	return result;
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
private static String waitForStatus(Session session, String jobId) throws DrmaaException {
	JobInfo jobInfo = session.wait(jobId, Session.TIMEOUT_WAIT_FOREVER);
	if (jobInfo.wasAborted()) {
		return RunStatus.ABORTED;
	}
	if (jobInfo.hasExited()) {
		return null;
	}
	if (jobInfo.hasSignaled()) {
		return RunStatus.SIGNALLED;
	}
	return RunStatus.DISAPPEARED;
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
public void clear() throws DrmaaException {
	logger.info("terminating all remaining jobs");
	session.control(Session.JOB_IDS_SESSION_ALL, Session.TERMINATE);
	currentJobs.clear();
	failedJobs.clear();
	shallStop = false;
}
 

import org.ggf.drmaa.Session; //导入依赖的package包/类
private void checkJob(FailAction fail, JobSpecification js) throws DrmaaException {
	String id = js.getJobId();
	int status = session.getJobProgramStatus(id);
	if (status == Session.DONE) {
		JobInfo info = session.wait(id, Session.TIMEOUT_NO_WAIT);
		if (info.wasAborted()) {
			logger.warning(js.getJobMessage("was aborted"));
			fail(fail, js);
			return;
		}
		if (info.hasSignaled()) {
			logger.warning(js.getJobMessage("signalled " + info.getTerminatingSignal()));
			fail(fail, js);
			return;
		}
		if (info.getExitStatus() != 0) {
			logger.warning(js.getJobMessage("exited with status " + info.getExitStatus()));
			fail(fail, js);
			return;
		}
		logger.info(js.getJobMessage("is done"));
		currentJobs.remove(id);
		return;
	}
	if (status == Session.FAILED) {
		logger.warning(js.getJobMessage("failed somehow"));
		fail(fail, js);
	}
}