/** This method simply lists the tools available */
public void listTools(HttpClient httpclient) {
Document cipresResponseDoc = cipresQuery(httpclient, baseURL + "/tool", "tools");
if (cipresResponseDoc != null) {
String elementName = "tool";
List tools = cipresResponseDoc.getRootElement().elements(elementName);
int count = 0;
for (Iterator iter = tools.iterator();
iter.hasNext(); ) { // let's get a count as to how many tools there are.
Element nextTool = (Element) iter.next();
count++;
}
String[] toolName = new String[count];
count = 0;
for (Iterator iter = tools.iterator(); iter.hasNext(); ) {
Element nextTool = (Element) iter.next();
String name = nextTool.elementText("toolId");
if (!StringUtil.blank(name) && count < toolName.length) {
ownerModule.logln(name);
}
name = nextTool.elementText("toolName");
if (!StringUtil.blank(name) && count < toolName.length) {
ownerModule.logln(" " + name);
}
count++;
}
}
}
/*.................................................................................................................*/
public void deleteAllJobs() {
if (checkUsernamePassword(
false)) { // TODO: check to see if a Zephyr run is ongoing, and warn user if so.
HttpClient httpclient = getHttpClient();
String[] jobURLs = getJobURLs(httpclient);
if (jobURLs != null) {
for (int job = 0; job < jobURLs.length; job++) {
deleteJob(httpclient, jobURLs[job]);
}
if (jobURLs.length == 0) ownerModule.logln("No CIPRes jobs to delete.");
else ownerModule.logln("All " + jobURLs.length + " CIPRes jobs deleted.");
}
}
}
/** Lists to the log the current jobs of the user */
public void listJobs(HttpClient httpclient) {
Document cipresResponseDoc = cipresQuery(httpclient, baseURL + "/job/" + username, "joblist");
if (cipresResponseDoc != null) {
String[] jobList = getJobURLs(cipresResponseDoc);
if (jobList != null)
for (int job = 0; job < jobList.length; job++) {
ownerModule.logln("\njob " + job + ": " + jobList[job]);
String status = getJobStatus(jobList[job]);
ownerModule.logln(" " + status);
String wd = getWorkingDirectory(jobList[job]);
ownerModule.logln(" " + wd);
}
}
}
/*.................................................................................................................*/
public boolean monitorAndCleanUpShell(String jobURL) {
boolean stillGoing = true;
if (!checkUsernamePassword(true)) {
return false;
}
lastModified = null;
if (outputFilePaths != null) {
lastModified = new long[outputFilePaths.length];
LongArray.deassignArray(lastModified);
}
String status = "";
while (!jobCompleted(jobURL) && stillGoing) {
if (StringUtil.blank(status))
ownerModule.logln(
"CIPRes Job Status: " + getJobStatus(jobURL) + " (" + StringUtil.getDateTime() + ")");
// if (jobSubmitted(jobURL))
// processOutputFiles();
try {
Thread.sleep(minPollIntervalSeconds * 1000);
} catch (InterruptedException e) {
MesquiteMessage.notifyProgrammer("InterruptedException in CIPRes monitoring");
return false;
}
stillGoing = watcher == null || watcher.continueShellProcess(null);
String newStatus = getJobStatus(jobURL);
if (newStatus != null && !newStatus.equalsIgnoreCase(status)) {
ownerModule.logln(
"CIPRes Job Status: " + newStatus + " (" + StringUtil.getDateTime() + ")");
status = newStatus;
} else ownerModule.log(".");
if (newStatus != null && newStatus.equalsIgnoreCase("SUBMITTED")) { // job is running
processOutputFiles(jobURL);
}
}
ownerModule.logln("CIPRes job completed.");
if (outputFileProcessor != null) {
if (rootDir != null) {
ownerModule.logln("About to download results from CIPRes.");
if (downloadResults(jobURL, rootDir, false))
outputFileProcessor.processCompletedOutputFiles(outputFilePaths);
else return false;
}
}
return true;
}
/*.................................................................................................................*/
public boolean downloadResults(
HttpClient httpclient, String jobURL, String rootDir, boolean onlyNewOrModified) {
String resultsUri = getResultsDirectory(jobURL);
if (StringUtil.notEmpty(resultsUri)) {
Document cipresResponseDoc = cipresQuery(httpclient, resultsUri, "results");
if (cipresResponseDoc != null) {
CipresJobFile[] cipresJobFiles = processFilesDocument(cipresResponseDoc);
if (cipresJobFiles == null || cipresJobFiles.length == 0) {
ownerModule.logln(cipresResponseDoc.toString());
return false;
}
for (int job = 0; job < cipresJobFiles.length; job++) {
if (!onlyNewOrModified || fileNewOrModified(previousCipresJobFiles, cipresJobFiles, job))
cipresDownload(
httpclient,
cipresJobFiles[job].getDownloadURL(),
rootDir + cipresJobFiles[job].getFileName());
}
previousCipresJobFiles = cipresJobFiles.clone();
return true;
}
}
return false;
}
/**
* this is the primary method that sends a query to the CIPRes REST service. It expects to receive
* an XML file, which it returns in Document if the root tag matc hes xmlRootTag
*/
public Document cipresQuery(HttpClient httpclient, String URL, String xmlRootTag) {
if (StringUtil.blank(URL)) return null;
try {
HttpGet httpget = new HttpGet(URL);
httpget.addHeader("cipres-appkey", CIPRESkey);
try {
HttpResponse response = httpclient.execute(httpget);
HttpEntity responseEntity = response.getEntity();
InputStream instream = responseEntity.getContent();
BufferedReader br = new BufferedReader(new InputStreamReader(instream));
String line = "";
StringBuffer sb = new StringBuffer();
while ((line = br.readLine()) != null) {
sb.append(line + StringUtil.lineEnding());
}
Document cipresResponseDoc = loadXMLFile(xmlRootTag, sb.toString());
if (cipresResponseDoc != null && verbose) {
ownerModule.logln(sb.toString());
}
if (cipresResponseDoc == null) {
Document errorDoc = loadXMLFile(sb.toString());
if (errorDoc != null) reportError(errorDoc, "Error in communicating with CIPRes", true);
}
EntityUtils.consume(response.getEntity());
return cipresResponseDoc;
} catch (IOException e) {
Debugg.printStackTrace(e);
} catch (Exception e) {
Debugg.printStackTrace(e);
}
} catch (Exception e) {
Debugg.printStackTrace(e);
}
return null;
}
/** Reports job status in the log. */
public void reportJobStatus(String jobURL) {
if (checkUsernamePassword(false)) {
HttpClient httpclient = getHttpClient();
Document cipresResponseDoc = cipresQuery(httpclient, jobURL, "jobstatus");
if (cipresResponseDoc != null) {
ownerModule.logln("CIPRes Job Status: " + jobStatusFromResponse(cipresResponseDoc));
}
}
}
public void reportError(Document doc, String noteToUser, boolean resetPassword) {
if (doc == null) return;
String displayMessage = doc.getRootElement().elementText("displayMessage");
String message = doc.getRootElement().elementText("message");
if (StringUtil.notEmpty(message)) {
if ("Authentication Error".equalsIgnoreCase(displayMessage)) {
if (resetPassword) password = "";
} else {
ownerModule.logln("\n******************");
ownerModule.logln(noteToUser);
ownerModule.logln(displayMessage);
ownerModule.logln(message);
List paramErrors = doc.getRootElement().elements("paramError");
if (paramErrors != null)
for (Iterator iter = paramErrors.iterator(); iter.hasNext(); ) {
Element nextEntry = (Element) iter.next();
String param = nextEntry.elementText("param");
String error = nextEntry.elementText("error");
ownerModule.logln(" " + param + ": " + error);
}
ownerModule.logln("\n******************\n");
}
}
}
public void processJobSubmissionResponse(Document cipresResponseDoc, MesquiteString jobURL) {
Element element = cipresResponseDoc.getRootElement().element("selfUri");
Element subelement = null;
if (element != null) subelement = element.element("url");
if ("false".equals(cipresResponseDoc.getRootElement().elementText("failed"))) {
element = cipresResponseDoc.getRootElement().element("metadata");
List entries = element.elements("entry");
String reportedJobID = "";
for (Iterator iter = entries.iterator(); iter.hasNext(); ) {
Element nextEntry = (Element) iter.next();
if ("clientJobId".equals(nextEntry.elementText("key")))
reportedJobID = nextEntry.elementText("value");
}
ownerModule.logln("\nJob successfully submitted to CIPRes.");
ownerModule.logln(" Job URL: " + subelement.getText());
ownerModule.logln(" Job ID: " + reportedJobID + "\n");
if (jobURL != null) jobURL.setValue(subelement.getText());
}
}
/** The core method that initiates a job on CIPRes. */
public boolean postJob(
HttpClient httpclient, MultipartEntityBuilder builder, MesquiteString jobURL) {
if (builder == null) return false;
String URL = baseURL + "/job/" + username;
HttpPost httppost = new HttpPost(URL);
httppost.addHeader("cipres-appkey", CIPRESkey);
// some of this from
// http://stackoverflow.com/questions/18964288/upload-a-file-through-an-http-form-via-multipartentitybuilder-with-a-progress
HttpEntity cipresEntity = builder.build();
httppost.setEntity(cipresEntity);
try {
HttpResponse response = httpclient.execute(httppost);
HttpEntity responseEntity = response.getEntity();
InputStream instream = responseEntity.getContent();
BufferedReader br = new BufferedReader(new InputStreamReader(instream));
StringBuffer sb = new StringBuffer();
String line = "";
while ((line = br.readLine()) != null) {
sb.append(line + StringUtil.lineEnding());
}
Document cipresResponseDoc = loadXMLFile("jobstatus", sb.toString()); // let's see how it went
boolean success = false;
if (cipresResponseDoc != null) {
processJobSubmissionResponse(cipresResponseDoc, jobURL);
if (verbose) ownerModule.logln(sb.toString());
if (jobURL != null) success = StringUtil.notEmpty(jobURL.getValue());
else success = true;
} else {
cipresResponseDoc = loadXMLFile(sb.toString());
reportError(cipresResponseDoc, "Error with CIPRes run", false);
}
EntityUtils.consume(response.getEntity());
return success;
} catch (IOException e) {
Debugg.printStackTrace(e);
}
return false;
}
/*.................................................................................................................*/
public void reprocessAceFileDirectory(
MesquiteFile file, MesquiteModule ownerModule, DNAData data, int it) {
if (data == null || file == null) return;
String aceFileDirectoryPath =
ChromaseqUtil.getAceFileDirectory(file.getDirectoryName(), ownerModule, data, it);
File aceFileDirectory = new File(aceFileDirectoryPath);
boolean addFragName = false; // control of this?
int currentRead = -1;
String dataFilePath = MesquiteFile.composePath(data.getProject().getHomeDirectoryName(), "");
boolean addingPhrapFailures = false;
AceFile ace = null;
MesquiteProject project = data.getProject();
if (project == null) return;
String processedAceFilePath = "";
MesquiteString fullName = null;
MesquiteString voucherCode = null;
String geneName = ChromaseqUtil.getGeneName(data);
if (aceFileDirectory.isDirectory()) {
int numPhdFiles = getNumPhdFilesInDirectory(aceFileDirectory, aceFileDirectoryPath);
fileNameTranslation = new String[5][numPhdFiles];
fillNameTranslation(data, it, numPhdFiles);
String[] files = aceFileDirectory.list();
for (int i = 0;
i < files.length;
i++) { // going through the folders and finding the ace files
if (files[i] != null) {
String filePath = aceFileDirectoryPath + MesquiteFile.fileSeparator + files[i];
String infoFilePath =
aceFileDirectoryPath + MesquiteFile.fileSeparator + ChromaseqUtil.infoFileName;
File cFile = new File(filePath);
if (cFile.exists()) {
if (!cFile.isDirectory()) {
if (files[i].endsWith(ChromaseqUtil.processedACESuffix + ".ace")) {
// don't do anything
} else if (files[i].endsWith(".ace")
&& !files[i].startsWith(".")
&& !addingPhrapFailures) {
ownerModule.logln("Processing ACE file: " + files[i]);
String baseName =
files[i].substring(
0, files[i].length() - 4); // this is the name of the sequence
processedAceFilePath =
aceFileDirectoryPath
+ MesquiteFile.fileSeparator
+ baseName
+ ChromaseqUtil.processedACESuffix
+ ".ace";
ace =
new AceFile(
filePath,
processedAceFilePath,
dataFilePath,
dataFilePath,
ownerModule,
processPolymorphisms,
polyThreshold,
false);
if (ace == null) return;
ace.setBaseName(baseName);
fullName = new MesquiteString(baseName);
voucherCode = new MesquiteString();
ChromaseqInfoFile.processInfoFile(infoFilePath, fullName, voucherCode);
String fragmentDirPath =
StringUtil.getAllButLastItem(
StringUtil.getAllButLastItem(
aceFileDirectoryPath, MesquiteFile.fileSeparator),
MesquiteFile.fileSeparator);
ace.setLongSequenceName(fullName.toString());
if (ace.getNumContigs() >= 1) {
processAceFileWithContig(
data,
ownerModule,
processedAceFilePath,
fragmentDirPath,
ace,
null,
geneName,
fullName,
baseName,
voucherCode,
it);
} else {
ownerModule.logln(" ACE file contains no contigs!");
if (project != null) {
addingPhrapFailures = true;
i = 0;
ace.createEmptyContigs(
MesquiteFile.numFilesEndingWith(
aceFileDirectoryPath, files, ".phd.1")); // create an empty contig
ace.renameContigs(fullName.toString(), addFragName, geneName);
}
}
if (!addingPhrapFailures) ace.dispose();
} else if (files[i].endsWith(".phd.1") && addingPhrapFailures) {
ownerModule.logln(" Importing single-read Phred file " + files[i]);
currentRead++;
ace.addPhdFileAsSingleReadInContig(
currentRead,
aceFileDirectoryPath,
files[i],
processPolymorphisms,
polyThreshold);
}
}
}
}
}
}
if (addingPhrapFailures && ace != null) { // have to process AceFile that we have manually made
MesquiteFile.putFileContents(processedAceFilePath, ace.toString(processPolymorphisms), true);
if (project != null) {
processAceFileWithoutContig(
data, processedAceFilePath, ace, geneName, fullName, it, voucherCode);
}
ace.dispose();
}
}