コード例 #1
0
 /** 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++;
     }
   }
 }
コード例 #2
0
 /*.................................................................................................................*/
 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.");
     }
   }
 }
コード例 #3
0
 /** 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);
       }
   }
 }
コード例 #4
0
  /*.................................................................................................................*/
  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;
  }
コード例 #5
0
  /*.................................................................................................................*/
  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;
  }
コード例 #6
0
 /**
  * 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;
 }
コード例 #7
0
 /** 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));
     }
   }
 }
コード例 #8
0
  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");
      }
    }
  }
コード例 #9
0
  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());
    }
  }
コード例 #10
0
  /** 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;
  }