How to use

XTriggerException

in

org.jenkinsci.lib.xtrigger

public void initForContent(String content, XTriggerLog log) throws XTriggerException {
  if (content == null) {
    throw new XTriggerException("The given content is not set.");
  }
  if (content.trim().isEmpty()) {
    throw new XTriggerException("The given content is empty.");
  }
  initForContentType(content, log);
}

  return null;
} catch (XTriggerException xe) {
  log.error("XTrigger exception: " + xe.getMessage());
  return null;

private Document initXMLFile(String content) throws XTriggerException {
  Document xmlDocument;
  try {
    StringReader stringReader = new StringReader(content);
    InputSource inputSource = new InputSource(stringReader);
    xmlDocument = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(inputSource);
    stringReader.close();
  } catch (SAXException e) {
    throw new XTriggerException(e);
  } catch (IOException e) {
    throw new XTriggerException(e);
  } catch (ParserConfigurationException e) {
    throw new XTriggerException(e);
  }
  return xmlDocument;
}

private SSLContext getSSLContext() throws XTriggerException {
  javax.net.ssl.TrustManager x509 = new javax.net.ssl.X509TrustManager() {
    @Override
    public void checkClientTrusted(java.security.cert.X509Certificate[] arg0, String arg1) throws java.security.cert.CertificateException {
    }
    @Override
    public void checkServerTrusted(java.security.cert.X509Certificate[] arg0, String arg1) throws java.security.cert.CertificateException {
    }
    @Override
    public java.security.cert.X509Certificate[] getAcceptedIssuers() {
      return null;
    }
  };
  SSLContext ctx;
  try {
    ctx = SSLContext.getInstance("SSL");
    ctx.init(null, new javax.net.ssl.TrustManager[]{x509}, null);
  } catch (java.security.GeneralSecurityException ex) {
    throw new XTriggerException(ex);
  }
  return ctx;
}

private Map<String, Object> readXMLPath(Document document) throws XTriggerException {
  Map<String, Object> results = new HashMap<String, Object>(xPaths.size());
  XPathFactory xPathFactory = XPathFactory.newInstance();
  XPath xPath = xPathFactory.newXPath();
  try {
    for (XMLContentEntry expressionEntry : xPaths) {
      String expression = expressionEntry.getXPath();
      XPathExpression xPathExpression = xPath.compile(expression);
      Object result = xPathExpression.evaluate(document);
      results.put(expression, result);
    }
  } catch (XPathExpressionException xpe) {
    throw new XTriggerException(xpe);
  }
  return results;
}

private Map<String, Object> readJsonPath(String content) throws XTriggerException {
  Map<String, Object> results = new HashMap<String, Object>(jsonPaths.size());
  try {
    for (JSONContentEntry jsonContentEntry : jsonPaths) {
      String jsonPath = jsonContentEntry.getJsonPath();
      Object result = JsonPath.read(content, jsonPath);
      results.put(jsonPath, result);
    }
  } catch (ParseException pe) {
    throw new XTriggerException(pe);
  }
  return results;
}

  throw new XTriggerException(ioe);
} catch (InterruptedException ie) {
  throw new XTriggerException(ie);

  throw new XTriggerException(ioe);
} finally {
  if (bufferedReader != null) {
      bufferedReader.close();
    } catch (IOException ioe) {
      throw new XTriggerException(ioe);

public static void validateJson(String content) throws XTriggerException {
  try {
    JsonParser parser = new JsonFactory().createJsonParser(content.getBytes());
    JsonToken currentToken = parser.nextToken();
    if (currentToken.equals(JsonToken.START_OBJECT)) {
      validateObject(parser);
    } else if (currentToken.equals(JsonToken.START_ARRAY)) {
      throw new XTriggerException("Json documents starting with arrays are not supported!");
    } else {
      throw new XTriggerException("Bad Json value starting with: " + currentToken.toString());
    }
  } catch (IOException ex) {
    throw new XTriggerException("Bad Json value: " + ex.getMessage());
  }
}

  @Override
  public Void call() throws XTriggerException {
    causeAction.setBuild(build);
    File triggerLogFile = causeAction.getLogFile();
    String logContent = causeAction.getLogMessage();
    try {
      FileUtils.writeStringToFile(triggerLogFile, logContent);
    } catch (IOException ioe) {
      throw new XTriggerException(ioe);
    }
    return null;
  }
});

protected Action[] getScheduledXTriggerActions(Node pollingNode, XTriggerLog log) throws XTriggerException {
  Action[] actions = getScheduledActions(pollingNode, log);
  int nbNewAction = actions.length + 1;
  Action[] newActions = new Action[nbNewAction];
  for (int i = 0; i < actions.length; i++) {
    newActions[i] = actions[i];
  }
  try {
    newActions[newActions.length - 1] = new XTriggerCauseAction(FileUtils.readFileToString(getLogFile()));
  } catch (IOException ioe) {
    throw new XTriggerException(ioe);
  }
  return newActions;
}

throw new XTriggerException("The size between old results and new results has to be the same.");
throw new XTriggerException("Regarding the set up of the result objects, the keys for the old results and the new results have to be the same.");

@SuppressWarnings("unused")
protected String resolveEnvVars(String value, AbstractProject project, Node node) throws XTriggerException {
  EnvVarsResolver varsResolver = new EnvVarsResolver();
  Map<String, String> envVars;
  try {
    envVars = varsResolver.getPollingEnvVars(project, node);
  } catch (EnvInjectException envInjectException) {
    throw new XTriggerException(envInjectException);
  }
  return Util.replaceMacro(value, envVars);
}

  throw new XTriggerException(pe);
} catch (IOException ioe) {
  throw new XTriggerException(ioe);
} finally {
  if (tempSettings != null) {

throw new XTriggerException("The size between old results and new results has to be the same.");
throw new XTriggerException("According the setup of the result objects, the keys for the old results and the new results have to be the same.");

private String getURLValue(URLTriggerEntry entry, Node node) throws XTriggerException {
  String entryURL = entry.getUrl();
  if (entryURL != null) {
    EnvVarsResolver varsRetriever = new EnvVarsResolver();
    Map<String, String> envVars;
    try {
      envVars = varsRetriever.getPollingEnvVars((AbstractProject) job, node);
    } catch (EnvInjectException e) {
      throw new XTriggerException(e);
    }
    return Util.replaceMacro(entryURL, envVars);
  }
  return null;
}

public void initContent(URLResponse clientResponse, URLTriggerEntry entry, XTriggerLog log) throws XTriggerException {
  if (clientResponse == null) {
    throw new NullPointerException("The given clientResponse object is not set.");
  }
  if (entry == null) {
    throw new NullPointerException("The given entry object is not set.");
  }
  Date lastModified = clientResponse.getLastModified();
  if (lastModified != null) {
    entry.setLastModificationDate(lastModified.getTime());
  } else {
    entry.setLastModificationDate(0);
  }
  if (entry.isInspectingContent()) {
    for (final URLTriggerContentType type : entry.getContentTypes()) {
      String stringContent = clientResponse.getContent();
      if (stringContent == null) {
        throw new XTriggerException("The URL content is empty.");
      }
      type.initForContent(stringContent, log);
    }
  }
}

  throw new XTriggerException(ioe);
} catch (InterruptedException ie) {
  throw new XTriggerException(ie);

throw new XTriggerException(ioe);

  envVars = varsRetriever.getPollingEnvVars(project, pollingNode);
} catch (EnvInjectException e) {
  throw new XTriggerException(e);
  temporaryPropertiesFilePath.delete();
} catch (IOException ioe) {
  throw new XTriggerException(ioe);
} catch (InterruptedException ie) {
  throw new XTriggerException(ie);