Export the definitions of all jobs that belongs to the given project
@@ -182,6 +188,9 @@ Method in class org.rundeck.api.RundeckClient
Export the definitions of the jobs that belongs to the given project, and matches the given criteria (jobFilter,
groupPath and jobIds), as an XML file
+
Get the definition of a single node
@@ -303,15 +345,24 @@ Method in class org.rundeck.api.getOsArch() -
Method in class org.rundeck.api.domain.RundeckNode
Run a RunDeck job (identified by the given ID), and wait until its execution is finished (or aborted) to return.
@@ -568,6 +658,21 @@ Method in class org.rundeck.api.setAbortedBy(String) -
Method in class org.rundeck.api.domain.RundeckExecution
getUrl()
@@ -461,6 +486,32 @@ Main entry point to talk to a RunDeck instance. String command,
Properties nodeFilters)
+
+ Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
runAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing)
+
+
+ Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
runAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing,
+ long poolingInterval,
+ TimeUnit poolingUnit)
+
Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
@@ -558,6 +609,18 @@ Main entry point to talk to a RunDeck instance. String command,
Properties nodeFilters)
+
+ Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
+
+
triggerAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing)
+
Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
+ The command will be dispatched to nodes, accordingly to the nodeFilters parameter.
+
+
+
+
+
+
Parameters:
project - name of the project - mandatory
command - to be executed - mandatory
nodeFilters - for selecting nodes on which the command will be executed. See NodeFiltersBuilder
nodeThreadcount - thread count to use (for parallelizing when running on multiple nodes) - optional
nodeKeepgoing - if true, continue executing on other nodes even if some fail - optional
+
Returns:
a RundeckExecution instance for the newly created (and running) execution - won't be null
+
Throws:
+
RundeckApiException - in case of error when calling the API (non-existent project with this name)
+
Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
+ server at regular interval (every 5 seconds) to know if the execution is finished (or aborted) or is still
+ running. The command will be dispatched to nodes, accordingly to the nodeFilters parameter.
+
+
+
+
+
+
Parameters:
project - name of the project - mandatory
command - to be executed - mandatory
nodeFilters - for selecting nodes on which the command will be executed. See NodeFiltersBuilder
nodeThreadcount - thread count to use (for parallelizing when running on multiple nodes) - optional
nodeKeepgoing - if true, continue executing on other nodes even if some fail - optional
+
Returns:
a RundeckExecution instance for the (finished/aborted) execution - won't be null
+
Throws:
+
RundeckApiException - in case of error when calling the API (non-existent project with this name)
+
Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
+ server at regular interval (configured by the poolingInterval/poolingUnit couple) to know if the execution is
+ finished (or aborted) or is still running. The command will be dispatched to nodes, accordingly to the
+ nodeFilters parameter.
+
+
+
+
+
+
Parameters:
project - name of the project - mandatory
command - to be executed - mandatory
nodeFilters - for selecting nodes on which the command will be executed. See NodeFiltersBuilder
nodeThreadcount - thread count to use (for parallelizing when running on multiple nodes) - optional
nodeKeepgoing - if true, continue executing on other nodes even if some fail - optional
poolingInterval - for checking the status of the execution. Must be > 0.
poolingUnit - unit (seconds, milli-seconds, ...) of the interval. Default to seconds.
+
Returns:
a RundeckExecution instance for the (finished/aborted) execution - won't be null
+
Throws:
+
RundeckApiException - in case of error when calling the API (non-existent project with this name)
+
RundeckClient.exportJobs(String project)
@@ -171,6 +179,15 @@ Uses of
+ void
+
RundeckClient.exportJobToFile(String filename,
+ String jobId)
+
+
+ Export the definition of a single job (identified by the given ID), as an XML file
RundeckClient.runAdhocCommand(String project,
String command)
@@ -343,6 +368,32 @@ Uses of String command,
Properties nodeFilters)
+
+ Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
RundeckClient.runAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing)
+
+
+ Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
RundeckClient.runAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing,
+ long poolingInterval,
+ TimeUnit poolingUnit)
+
Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
@@ -432,6 +483,18 @@ Uses of String command,
Properties nodeFilters)
+
+ Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
+
+
RundeckClient.triggerAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing)
+
Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
diff --git a/apidocs/org/rundeck/api/class-use/RundeckApiException.html b/apidocs/org/rundeck/api/class-use/RundeckApiException.html
index efb0ce6..0ab7f83 100644
--- a/apidocs/org/rundeck/api/class-use/RundeckApiException.html
+++ b/apidocs/org/rundeck/api/class-use/RundeckApiException.html
@@ -2,13 +2,13 @@
-
+
Uses of Class org.rundeck.api.RundeckApiException (RunDeck API - Java Client 1.0-SNAPSHOT API)
-
+
@@ -150,6 +150,14 @@ Uses of
RundeckClient.exportJobs(String project)
@@ -191,6 +199,15 @@ Uses of
+ void
+
RundeckClient.exportJobToFile(String filename,
+ String jobId)
+
+
+ Export the definition of a single job (identified by the given ID), as an XML file
RundeckClient.getSystemInfo()
+
+
+ Get system informations about the RunDeck server
+
+
+
void
RundeckClient.ping()
@@ -371,6 +396,32 @@ Uses of String command,
Properties nodeFilters)
+
+ Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
RundeckClient.runAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing)
+
+
+ Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
RundeckClient.runAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing,
+ long poolingInterval,
+ TimeUnit poolingUnit)
+
Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
@@ -452,6 +503,18 @@ Uses of String command,
Properties nodeFilters)
+
+ Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
+
+
RundeckClient.triggerAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing)
+
Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
RundeckClient.runAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing)
+
+
+ Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
RundeckClient.runAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing,
+ long poolingInterval,
+ TimeUnit poolingUnit)
+
Run an ad-hoc command, and wait until its execution is finished (or aborted) to return.
@@ -235,6 +261,18 @@ Uses of String command,
Properties nodeFilters)
+
+ Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
+
+
RundeckClient.triggerAdhocCommand(String project,
+ String command,
+ Properties nodeFilters,
+ Integer nodeThreadcount,
+ Boolean nodeKeepgoing)
+
Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
diff --git a/apidocs/org/rundeck/api/domain/class-use/RundeckJob.html b/apidocs/org/rundeck/api/domain/class-use/RundeckJob.html
index 3da8b4e..760843d 100644
--- a/apidocs/org/rundeck/api/domain/class-use/RundeckJob.html
+++ b/apidocs/org/rundeck/api/domain/class-use/RundeckJob.html
@@ -2,13 +2,13 @@
-
+
Uses of Class org.rundeck.api.domain.RundeckJob (RunDeck API - Java Client 1.0-SNAPSHOT API)
-
+
diff --git a/apidocs/org/rundeck/api/domain/class-use/RundeckNode.html b/apidocs/org/rundeck/api/domain/class-use/RundeckNode.html
index ef404c0..dad67e1 100644
--- a/apidocs/org/rundeck/api/domain/class-use/RundeckNode.html
+++ b/apidocs/org/rundeck/api/domain/class-use/RundeckNode.html
@@ -2,13 +2,13 @@
-
+
Uses of Class org.rundeck.api.domain.RundeckNode (RunDeck API - Java Client 1.0-SNAPSHOT API)
-
+
diff --git a/apidocs/org/rundeck/api/domain/class-use/RundeckProject.html b/apidocs/org/rundeck/api/domain/class-use/RundeckProject.html
index 83531c7..cd61f29 100644
--- a/apidocs/org/rundeck/api/domain/class-use/RundeckProject.html
+++ b/apidocs/org/rundeck/api/domain/class-use/RundeckProject.html
@@ -2,13 +2,13 @@
-
+
Uses of Class org.rundeck.api.domain.RundeckProject (RunDeck API - Java Client 1.0-SNAPSHOT API)
-
+
diff --git a/apidocs/org/rundeck/api/domain/class-use/RundeckSystemInfo.html b/apidocs/org/rundeck/api/domain/class-use/RundeckSystemInfo.html
new file mode 100644
index 0000000..7960071
--- /dev/null
+++ b/apidocs/org/rundeck/api/domain/class-use/RundeckSystemInfo.html
@@ -0,0 +1,210 @@
+
+
+
+
+
+
+
+Uses of Class org.rundeck.api.domain.RundeckSystemInfo (RunDeck API - Java Client 1.0-SNAPSHOT API)
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Description: The codec package contains simple encoder and decoders for
various formats such as Base64 and Hexadecimal. In addition to these
widely used encoders and decoders, the codec package also maintains a
- collection of phonetic encoding utilities.
Description: Commons Lang, a package of Java utility classes for the
classes that are in java.lang's hierarchy, or are considered to be so
- standard as to justify existence in java.lang.
Project License: No project license is defined for this project.
xml-apis:xml-apis:jar:1.0.b2 (compile)
XML Commons External Components XML APIs
Description: xml-commons provides an Apache-hosted set of DOM, SAX, and
JAXP interfaces for use in other xml-based projects. Our hope is that we
can standardize on both a common version and packaging scheme for these
critical XML standards interfaces to make the lives of both our developers
and users easier. The External Components portion of xml-commons contains
interfaces that are defined by external standards organizations. For DOM,
that's the W3C; for SAX it's David Megginson and sax.sourceforge.net; for
- JAXP it's Sun.
Description: There is currently no description associated with this project.
Project License: No project license is defined for this project.
xerces:xercesImpl:jar:2.6.2 (compile)
Unnamed - xerces:xercesImpl:jar:2.6.2
Description: There is currently no description associated with this project.
Project License: No project license is defined for this project.
xalan:xalan:jar:2.6.0 (compile)
Unnamed - xalan:xalan:jar:2.6.0
Description: There is currently no description associated with this project.
Project License: No project license is defined for this project.
xml-apis:xml-apis:jar:1.0.b2 (compile)
XML Commons External Components XML APIs
Description: xml-commons provides an Apache-hosted set of DOM, SAX, and
JAXP interfaces for use in other xml-based projects. Our hope is that we
can standardize on both a common version and packaging scheme for these
critical XML standards interfaces to make the lives of both our developers
and users easier. The External Components portion of xml-commons contains
interfaces that are defined by external standards organizations. For DOM,
that's the W3C; for SAX it's David Megginson and sax.sourceforge.net; for
- JAXP it's Sun.
The Apache Software License, Version 2.0: Commons Codec, Commons IO, Commons Lang, Commons Logging, RunDeck API - Java Client, XML Commons External Components XML APIs
The Apache Software License, Version 2.0: Commons Codec, Commons IO, Commons Lang, Commons Logging, RunDeck API - Java Client, XML Commons External Components XML APIs
Here are some examples of what you can do with this lib and a few lines of Groovy.
We can use Grape to download the lib (and its dependencies) from the Maven Central Repository, so you don't have to install anything manually (except Groovy, of course).
Note that the lib is NOT in the Maven Central Repository for the moment... but hopefully it should be pretty soon ! You can still download it manually.
Basic usage
Save the following script in a file named "rundeck.groovy", and execute it with "groovy rundeck.groovy". Feeling Groovy ? ;-)
// we use Grape (Ivy) to download the lib (and its dependencies) from Maven Central Repository
-@Grab(group='org.rundeck', module='rundeck-api-java-client', version='1.0-SNAPSHOT')
+
Using the RunDeck API from Groovy scripts
Here are some examples of what you can do with this lib and a few lines of Groovy.
We can use Grape to download the lib (and its dependencies) from the Maven Central Repository, so you don't have to install anything manually (except Groovy, of course).
Basic usage
Save the following script in a file named "rundeck.groovy", and execute it with "groovy rundeck.groovy". Feeling Groovy ? ;-)
// we use Grape (Ivy) to download the lib (and its dependencies) from Maven Central Repository
+@Grab(group='org.rundeck', module='rundeck-api-java-client', version='1.0')
import org.rundeck.api.RundeckClient
rundeck = new RundeckClient("http://localhost:4440", "admin", "admin")
+println "RunDeck uptime : ${rundeck.systemInfo.uptime}"
println "All RunDeck projects : ${rundeck.projects}"
println "All RunDeck nodes : ${rundeck.nodes}"
println "All RunDeck jobs : ${rundeck.jobs}"
@@ -122,6 +126,7 @@ println "All RunDeck running executions : ${rundeck.runningExecutions}"
rundeck = new RundeckClient("http://localhost:4440", "admin", "admin")
+println "RunDeck uptime : ${rundeck.systemInfo.uptime}"
println "All RunDeck projects : ${rundeck.projects}"
println "All RunDeck nodes : ${rundeck.nodes}"
println "All RunDeck jobs : ${rundeck.jobs}"
@@ -158,6 +163,7 @@ execution = rundeck.runAdhocCommand("my-project", "uptime",
rundeck = new RundeckClient("http://localhost:4440", "admin", "admin")
rundeck.exportJobsToFile("/tmp/jobs.xml", "my-project")
+rundeck.exportJobToFile("/tmp/job.xml", "job-id")
And more...
See the API documentation of the RundeckClient class for more interactions with your RunDeck instance...
A Java library that maps the RunDeck HTTP REST API. RunDeck is an open-source tool for automating tasks on multiple nodes, with a CLI, a web-based interface and an HTTP REST API. You can read more about its API on the RunDeck User Manual.
This library has been extracted from the Jenkins RunDeck plugin, so for the moment it is still incomplete (not all the RunDeck API is mapped). My goal is to have a complete mapping of the RunDeck API, and to publish the library on the Maven Central Repository, so that it can easily be used by Java (Maven) and Groovy (Grape) developers.
What can I do with it ?
Use it to write scripts (in Groovy, JRuby or Jython), for example if you want to automate the execution of RunDeck jobs based on external events.
Use it in a Java application. A good example would be the Jenkins RunDeck plugin, that needs to trigger RunDeck jobs from within the Jenkins continuous-integration server.
A Java client (library) for the RunDeck HTTP REST API.
RunDeck is an open-source tool for automating tasks on multiple nodes, with a CLI, a web-based interface and an HTTP REST API. You can read more about its API on the RunDeck User Manual.
What can I do with it ?
Use it to write scripts (in Groovy, JRuby or Jython), for example if you want to automate the execution of RunDeck jobs based on external events.
Use it in a Java application. A good example would be the Jenkins RunDeck plugin, that needs to trigger RunDeck jobs from within the Jenkins continuous-integration server.
This document provides an overview of the various documents and links that are part of this project's general information. All of this content is automatically generated by Maven on behalf of the project.
This document provides information on the members of this project. These are the individuals who have contributed to the project in one form or another.
This is a link to the definitions of project licenses.
+
Project Information
This document provides an overview of the various documents and links that are part of this project's general information. All of this content is automatically generated by Maven on behalf of the project.
This document provides information on the members of this project. These are the individuals who have contributed to the project in one form or another.
+
+1/*
+2 * Copyright 2011 Vincent Behar
+3 *
+4 * Licensed under the Apache License, Version 2.0 (the "License");
+5 * you may not use this file except in compliance with the License.
+6 * You may obtain a copy of the License at
+7 *
+8 * http://www.apache.org/licenses/LICENSE-2.0
+9 *
+10 * Unless required by applicable law or agreed to in writing, software
+11 * distributed under the License is distributed on an "AS IS" BASIS,
+12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+13 * See the License for the specific language governing permissions and
+14 * limitations under the License.
+15 */
+16package org.rundeck.api.parser;
+17
+18import java.io.InputStream;
+19import java.util.Date;
+20import org.dom4j.Document;
+21import org.junit.Assert;
+22import org.junit.Test;
+23import org.rundeck.api.domain.RundeckSystemInfo;
+24
+25/**
+26 * Test the {@link SystemInfoParser}
+27 *
+28 * @author Vincent Behar
+29 */
+30publicclassSystemInfoParserTest {
+31
+32 @Test
+33publicvoid parseProject() throws Exception {
+34 InputStream input = getClass().getResourceAsStream("system-info.xml");
+35 Document document = ParserHelper.loadDocument(input);
+36
+37 RundeckSystemInfo info = new SystemInfoParser("result/system").parseXmlNode(document);
+38
+39 Assert.assertEquals(new Date(1310051857605L), info.getDate());
+40 Assert.assertEquals("1.2.1", info.getVersion());
+41 Assert.assertEquals("1.2.1-1", info.getBuild());
+42 Assert.assertEquals("strongbad", info.getNode());
+43 Assert.assertEquals("/opt/rundeck/rundeck-1.2.1", info.getBaseDir());
+44 Assert.assertEquals("i386", info.getOsArch());
+45 Assert.assertEquals("Linux", info.getOsName());
+46 Assert.assertEquals("2.6.35-30-generic-pae", info.getOsVersion());
+47 Assert.assertEquals("Java HotSpot(TM) Server VM", info.getJvmName());
+48 Assert.assertEquals("Sun Microsystems Inc.", info.getJvmVendor());
+49 Assert.assertEquals("19.1-b02", info.getJvmVersion());
+50 Assert.assertEquals(new Date(1310032513574L), info.getStartDate());
+51 Assert.assertEquals(new Long(19344031), info.getUptimeInMillis());
+52 Assert.assertEquals("5 hours 22 minutes 24 seconds", info.getUptime());
+53 Assert.assertEquals("0.1 %", info.getCpuLoadAverage());
+54 Assert.assertEquals(new Long(954466304), info.getMaxMemoryInBytes());
+55 Assert.assertEquals(new Long(159576592), info.getFreeMemoryInBytes());
+56 Assert.assertEquals(new Long(271384576), info.getTotalMemoryInBytes());
+57 Assert.assertEquals(new Integer(0), info.getRunningJobs());
+58 Assert.assertEquals(new Integer(25), info.getActiveThreads());
+59 }
+60
+61 }
+
XmlNodeParser
diff --git a/xref/org/rundeck/api/ApiPathBuilder.html b/xref/org/rundeck/api/ApiPathBuilder.html
index 6ea4049..3244960 100644
--- a/xref/org/rundeck/api/ApiPathBuilder.html
+++ b/xref/org/rundeck/api/ApiPathBuilder.html
@@ -94,48 +94,78 @@
84 }
8586/**
-87 * Append the given node filters, only if it is not null/empty
-88 *
-89 * @param nodeFilters may be null/empty
-90 * @return this, for method chaining
-91 * @see ParametersUtil#generateNodeFiltersString(Properties)
-92 */
-93publicApiPathBuilder nodeFilters(Properties nodeFilters) {
-94 String filters = ParametersUtil.generateNodeFiltersString(nodeFilters);
-95if (StringUtils.isNotBlank(filters)) {
-96 appendSeparator();
-97 append(filters);
-98 }
-99returnthis;
-100 }
-101
-102 @Override
-103public String toString() {
-104return apiPath.toString();
-105 }
-106
-107/**
-108 * Append the given string
-109 *
-110 * @param str to append
-111 */
-112privatevoid append(String str) {
-113 apiPath.append(str);
+87 * Append the given parameter (key and value). This will only append the parameter if it is not null, and make sure
+88 * to add the right separator ("?" or "&") before. The key and value will be separated by the "=" character.
+89 *
+90 * @param key of the parameter. Must not be null or empty
+91 * @param value of the parameter. May be null
+92 * @return this, for method chaining
+93 */
+94publicApiPathBuilder param(String key, Integer value) {
+95if (value != null) {
+96 param(key, value.toString());
+97 }
+98returnthis;
+99 }
+100
+101/**
+102 * Append the given parameter (key and value). This will only append the parameter if it is not null, and make sure
+103 * to add the right separator ("?" or "&") before. The key and value will be separated by the "=" character.
+104 *
+105 * @param key of the parameter. Must not be null or empty
+106 * @param value of the parameter. May be null
+107 * @return this, for method chaining
+108 */
+109publicApiPathBuilder param(String key, Boolean value) {
+110if (value != null) {
+111 param(key, value.toString());
+112 }
+113returnthis;
114 }
115116/**
-117 * Append the right separator "?" or "&" between 2 parameters
-118 */
-119privatevoid appendSeparator() {
-120if (firstParamDone) {
-121 append("&");
-122 } else {
-123 append("?");
-124 firstParamDone = true;
-125 }
-126 }
-127
-128 }
+117 * Append the given node filters, only if it is not null/empty
+118 *
+119 * @param nodeFilters may be null/empty
+120 * @return this, for method chaining
+121 * @see ParametersUtil#generateNodeFiltersString(Properties)
+122 */
+123publicApiPathBuilder nodeFilters(Properties nodeFilters) {
+124 String filters = ParametersUtil.generateNodeFiltersString(nodeFilters);
+125if (StringUtils.isNotBlank(filters)) {
+126 appendSeparator();
+127 append(filters);
+128 }
+129returnthis;
+130 }
+131
+132 @Override
+133public String toString() {
+134return apiPath.toString();
+135 }
+136
+137/**
+138 * Append the given string
+139 *
+140 * @param str to append
+141 */
+142privatevoid append(String str) {
+143 apiPath.append(str);
+144 }
+145
+146/**
+147 * Append the right separator "?" or "&" between 2 parameters
+148 */
+149privatevoid appendSeparator() {
+150if (firstParamDone) {
+151 append("&");
+152 } else {
+153 append("?");
+154 firstParamDone = true;
+155 }
+156 }
+157
+158 }
diff --git a/xref/org/rundeck/api/RundeckClient.html b/xref/org/rundeck/api/RundeckClient.html
index 2656cc2..a0cddb4 100644
--- a/xref/org/rundeck/api/RundeckClient.html
+++ b/xref/org/rundeck/api/RundeckClient.html
@@ -42,875 +42,1005 @@
32import org.rundeck.api.domain.RundeckJob;
33import org.rundeck.api.domain.RundeckNode;
34import org.rundeck.api.domain.RundeckProject;
-35import org.rundeck.api.domain.RundeckExecution.ExecutionStatus;
-36import org.rundeck.api.parser.AbortParser;
-37import org.rundeck.api.parser.ExecutionParser;
-38import org.rundeck.api.parser.JobParser;
-39import org.rundeck.api.parser.ListParser;
-40import org.rundeck.api.parser.NodeParser;
-41import org.rundeck.api.parser.ProjectParser;
-42import org.rundeck.api.parser.StringParser;
-43import org.rundeck.api.util.AssertUtil;
-44import org.rundeck.api.util.ParametersUtil;
-45
-46/**
-47 * Main entry point to talk to a RunDeck instance.<br>
-48 * Usage : <br>
-49 * <code>
-50 * <pre>
-51 * RundeckClient rundeck = new RundeckClient("http://localhost:4440", "admin", "admin");
-52 * List<RundeckJob> jobs = rundeck.getJobs();
-53 *
-54 * RundeckJob job = rundeck.findJob("my-project", "main-group/sub-group", "job-name");
-55 * RundeckExecution execution = rundeck.triggerJob(job.getId(),
-56 * new OptionsBuilder().addOption("version", "1.2.0").toProperties());
-57 *
-58 * List<RundeckExecution> runningExecutions = rundeck.getRunningExecutions("my-project");
-59 * </pre>
-60 * </code>
-61 *
-62 * @author Vincent Behar
-63 */
-64publicclassRundeckClientimplements Serializable {
-65
-66privatestaticfinallong serialVersionUID = 1L;
+35import org.rundeck.api.domain.RundeckSystemInfo;
+36import org.rundeck.api.domain.RundeckExecution.ExecutionStatus;
+37import org.rundeck.api.parser.AbortParser;
+38import org.rundeck.api.parser.ExecutionParser;
+39import org.rundeck.api.parser.JobParser;
+40import org.rundeck.api.parser.ListParser;
+41import org.rundeck.api.parser.NodeParser;
+42import org.rundeck.api.parser.ProjectParser;
+43import org.rundeck.api.parser.StringParser;
+44import org.rundeck.api.parser.SystemInfoParser;
+45import org.rundeck.api.util.AssertUtil;
+46import org.rundeck.api.util.ParametersUtil;
+47
+48/**
+49 * Main entry point to talk to a RunDeck instance.<br>
+50 * Usage : <br>
+51 * <code>
+52 * <pre>
+53 * RundeckClient rundeck = new RundeckClient("http://localhost:4440", "admin", "admin");
+54 * List<RundeckJob> jobs = rundeck.getJobs();
+55 *
+56 * RundeckJob job = rundeck.findJob("my-project", "main-group/sub-group", "job-name");
+57 * RundeckExecution execution = rundeck.triggerJob(job.getId(),
+58 * new OptionsBuilder().addOption("version", "1.2.0").toProperties());
+59 *
+60 * List<RundeckExecution> runningExecutions = rundeck.getRunningExecutions("my-project");
+61 * </pre>
+62 * </code>
+63 *
+64 * @author Vincent Behar
+65 */
+66publicclassRundeckClientimplements Serializable {
67
-68publicstaticfinaltransientint API_VERSION = 1;
+68privatestaticfinallong serialVersionUID = 1L;
69
-70publicstaticfinaltransient String API_ENDPOINT = "/api/" + API_VERSION;
+70publicstaticfinaltransientint API_VERSION = 1;
71
-72privatefinal String url;
+72publicstaticfinaltransient String API_ENDPOINT = "/api/" + API_VERSION;
73
-74privatefinal String login;
+74privatefinal String url;
75
-76privatefinal String password;
+76privatefinal String login;
77
-78/**
-79 * Instantiate a new {@link RundeckClient} for the RunDeck instance at the given url
-80 *
-81 * @param url of the RunDeck instance ("http://localhost:4440", "http://rundeck.your-compagny.com/", etc)
-82 * @param login
-83 * @param password
-84 * @throws IllegalArgumentException if the url, login or password is blank (null, empty or whitespace)
-85 */
-86publicRundeckClient(String url, String login, String password) throws IllegalArgumentException {
-87super();
-88this.url = url;
-89this.login = login;
-90this.password = password;
-91 AssertUtil.notBlank(url, "The RunDeck URL is mandatory !");
-92 AssertUtil.notBlank(login, "The RunDeck login is mandatory !");
-93 AssertUtil.notBlank(password, "The RunDeck password is mandatory !");
-94 }
-95
-96/**
-97 * Try to "ping" the RunDeck instance to see if it is alive
-98 *
-99 * @throws RundeckApiException if the ping fails
-100 */
-101publicvoid ping() throws RundeckApiException {
-102newApiCall(this).ping();
-103 }
-104
-105/**
-106 * Test your credentials (login/password) on the RunDeck instance
-107 *
-108 * @throws RundeckApiLoginException if the login fails
-109 */
-110publicvoid testCredentials() throws RundeckApiLoginException {
-111newApiCall(this).testCredentials();
-112 }
-113
-114/*
-115 * Projects
-116 */
-117
-118/**
-119 * List all projects
-120 *
-121 * @return a {@link List} of {@link RundeckProject} : might be empty, but won't be null
-122 * @throws RundeckApiException in case of error when calling the API
-123 * @throws RundeckApiLoginException if the login failed
-124 */
-125public List<RundeckProject> getProjects() throws RundeckApiException, RundeckApiLoginException {
-126returnnewApiCall(this).get(newApiPathBuilder("/projects"),
-127new ListParser<RundeckProject>(newProjectParser(), "result/projects/project"));
-128 }
-129
-130/**
-131 * Get the definition of a single project, identified by the given name
-132 *
-133 * @param projectName name of the project - mandatory
-134 * @return a {@link RundeckProject} instance - won't be null
-135 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-136 * @throws RundeckApiLoginException if the login failed
-137 * @throws IllegalArgumentException if the projectName is blank (null, empty or whitespace)
-138 */
-139publicRundeckProject getProject(String projectName) throws RundeckApiException, RundeckApiLoginException,
-140 IllegalArgumentException {
-141 AssertUtil.notBlank(projectName, "projectName is mandatory to get the details of a project !");
-142returnnewApiCall(this).get(newApiPathBuilder("/project/", projectName),
-143newProjectParser("result/projects/project"));
-144 }
-145
-146/*
-147 * Jobs
-148 */
-149
-150/**
-151 * List all jobs (for all projects)
-152 *
-153 * @return a {@link List} of {@link RundeckJob} : might be empty, but won't be null
-154 * @throws RundeckApiException in case of error when calling the API
-155 * @throws RundeckApiLoginException if the login failed
-156 */
-157public List<RundeckJob> getJobs() throws RundeckApiException, RundeckApiLoginException {
-158 List<RundeckJob> jobs = new ArrayList<RundeckJob>();
-159for (RundeckProject project : getProjects()) {
-160 jobs.addAll(getJobs(project.getName()));
-161 }
-162return jobs;
-163 }
-164
-165/**
-166 * List all jobs that belongs to the given project
-167 *
-168 * @param project name of the project - mandatory
-169 * @return a {@link List} of {@link RundeckJob} : might be empty, but won't be null
-170 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-171 * @throws RundeckApiLoginException if the login failed
-172 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
-173 * @see #getJobs(String, String, String, String...)
-174 */
-175public List<RundeckJob> getJobs(String project) throws RundeckApiException, RundeckApiLoginException,
-176 IllegalArgumentException {
-177return getJobs(project, null, null, new String[0]);
-178 }
-179
-180/**
-181 * List the jobs that belongs to the given project, and matches the given criteria (jobFilter, groupPath and jobIds)
-182 *
-183 * @param project name of the project - mandatory
-184 * @param jobFilter a filter for the job Name - optional
-185 * @param groupPath a group or partial group path to include all jobs within that group path - optional
-186 * @param jobIds a list of Job IDs to include - optional
-187 * @return a {@link List} of {@link RundeckJob} : might be empty, but won't be null
-188 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-189 * @throws RundeckApiLoginException if the login failed
-190 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
-191 * @see #getJobs(String)
-192 */
-193public List<RundeckJob> getJobs(String project, String jobFilter, String groupPath, String... jobIds)
-194throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
-195 AssertUtil.notBlank(project, "project is mandatory to get all jobs !");
-196returnnewApiCall(this).get(newApiPathBuilder("/jobs").param("project", project)
-197 .param("jobFilter", jobFilter)
-198 .param("groupPath", groupPath)
-199 .param("idlist", StringUtils.join(jobIds, ",")),
-200new ListParser<RundeckJob>(newJobParser(), "result/jobs/job"));
-201 }
-202
-203/**
-204 * Export the definitions of all jobs that belongs to the given project, as an XML file
-205 *
-206 * @param filename path of the file where the content should be saved
-207 * @param project name of the project - mandatory
-208 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-209 * @throws RundeckApiLoginException if the login failed
-210 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
-211 * @throws IOException if we failed to write to the file
-212 * @see #exportJobsToFile(String, String, String, String, String...)
-213 * @see #exportJobs(String)
-214 */
-215publicvoid exportJobsToFile(String filename, String project) throws RundeckApiException, RundeckApiLoginException,
-216 IllegalArgumentException, IOException {
-217 exportJobsToFile(filename, project, null, null, new String[0]);
-218 }
-219
-220/**
-221 * Export the definitions of the jobs that belongs to the given project, and matches the given criteria (jobFilter,
-222 * groupPath and jobIds), as an XML file
-223 *
-224 * @param filename path of the file where the content should be saved
-225 * @param project name of the project - mandatory
-226 * @param jobFilter a filter for the job Name - optional
-227 * @param groupPath a group or partial group path to include all jobs within that group path - optional
-228 * @param jobIds a list of Job IDs to include - optional
-229 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-230 * @throws RundeckApiLoginException if the login failed
-231 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
-232 * @throws IOException if we failed to write to the file
-233 * @see #exportJobsToFile(String, String)
-234 * @see #exportJobs(String, String, String, String...)
-235 */
-236publicvoid exportJobsToFile(String filename, String project, String jobFilter, String groupPath, String... jobIds)
-237throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException, IOException {
-238 InputStream inputStream = exportJobs(project, jobFilter, groupPath, jobIds);
-239 FileUtils.writeByteArrayToFile(new File(filename), IOUtils.toByteArray(inputStream));
-240 }
-241
-242/**
-243 * Export the definitions of all jobs that belongs to the given project
-244 *
-245 * @param project name of the project - mandatory
-246 * @return an {@link InputStream} instance, not linked to any network resources - won't be null
-247 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-248 * @throws RundeckApiLoginException if the login failed
-249 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
-250 * @see #exportJobs(String, String, String, String...)
-251 * @see #exportJobsToFile(String, String)
-252 */
-253public InputStream exportJobs(String project) throws RundeckApiException, RundeckApiLoginException,
-254 IllegalArgumentException {
-255return exportJobs(project, null, null, new String[0]);
-256 }
-257
-258/**
-259 * Export the definitions of the jobs that belongs to the given project, and matches the given criteria (jobFilter,
-260 * groupPath and jobIds)
-261 *
-262 * @param project name of the project - mandatory
-263 * @param jobFilter a filter for the job Name - optional
-264 * @param groupPath a group or partial group path to include all jobs within that group path - optional
-265 * @param jobIds a list of Job IDs to include - optional
-266 * @return an {@link InputStream} instance, not linked to any network resources - won't be null
-267 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-268 * @throws RundeckApiLoginException if the login failed
-269 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
-270 * @see #exportJobs(String)
-271 * @see #exportJobsToFile(String, String, String, String, String...)
-272 */
-273public InputStream exportJobs(String project, String jobFilter, String groupPath, String... jobIds)
-274throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
-275 AssertUtil.notBlank(project, "project is mandatory to export all jobs !");
-276returnnewApiCall(this).get(newApiPathBuilder("/jobs/export").param("project", project)
-277 .param("jobFilter", jobFilter)
-278 .param("groupPath", groupPath)
-279 .param("idlist", StringUtils.join(jobIds, ",")));
-280 }
-281
-282/**
-283 * Find a job, identified by its project, group and name. Note that the groupPath is optional, as a job does not
-284 * need to belong to a group (either pass null, or an empty string).
-285 *
-286 * @param project name of the project - mandatory
-287 * @param groupPath group to which the job belongs (if it belongs to a group) - optional
-288 * @param name of the job to find - mandatory
-289 * @return a {@link RundeckJob} instance - null if not found
-290 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-291 * @throws RundeckApiLoginException if the login failed
-292 * @throws IllegalArgumentException if the project or the name is blank (null, empty or whitespace)
-293 */
-294publicRundeckJob findJob(String project, String groupPath, String name) throws RundeckApiException,
-295 RundeckApiLoginException, IllegalArgumentException {
-296 AssertUtil.notBlank(project, "project is mandatory to find a job !");
-297 AssertUtil.notBlank(name, "job name is mandatory to find a job !");
-298 List<RundeckJob> jobs = getJobs(project, name, groupPath, new String[0]);
-299return jobs.isEmpty() ? null : jobs.get(0);
+78privatefinal String password;
+79
+80/**
+81 * Instantiate a new {@link RundeckClient} for the RunDeck instance at the given url
+82 *
+83 * @param url of the RunDeck instance ("http://localhost:4440", "http://rundeck.your-compagny.com/", etc)
+84 * @param login
+85 * @param password
+86 * @throws IllegalArgumentException if the url, login or password is blank (null, empty or whitespace)
+87 */
+88publicRundeckClient(String url, String login, String password) throws IllegalArgumentException {
+89super();
+90this.url = url;
+91this.login = login;
+92this.password = password;
+93 AssertUtil.notBlank(url, "The RunDeck URL is mandatory !");
+94 AssertUtil.notBlank(login, "The RunDeck login is mandatory !");
+95 AssertUtil.notBlank(password, "The RunDeck password is mandatory !");
+96 }
+97
+98/**
+99 * Try to "ping" the RunDeck instance to see if it is alive
+100 *
+101 * @throws RundeckApiException if the ping fails
+102 */
+103publicvoid ping() throws RundeckApiException {
+104newApiCall(this).ping();
+105 }
+106
+107/**
+108 * Test your credentials (login/password) on the RunDeck instance
+109 *
+110 * @throws RundeckApiLoginException if the login fails
+111 */
+112publicvoid testCredentials() throws RundeckApiLoginException {
+113newApiCall(this).testCredentials();
+114 }
+115
+116/*
+117 * Projects
+118 */
+119
+120/**
+121 * List all projects
+122 *
+123 * @return a {@link List} of {@link RundeckProject} : might be empty, but won't be null
+124 * @throws RundeckApiException in case of error when calling the API
+125 * @throws RundeckApiLoginException if the login failed
+126 */
+127public List<RundeckProject> getProjects() throws RundeckApiException, RundeckApiLoginException {
+128returnnewApiCall(this).get(newApiPathBuilder("/projects"),
+129new ListParser<RundeckProject>(newProjectParser(), "result/projects/project"));
+130 }
+131
+132/**
+133 * Get the definition of a single project, identified by the given name
+134 *
+135 * @param projectName name of the project - mandatory
+136 * @return a {@link RundeckProject} instance - won't be null
+137 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+138 * @throws RundeckApiLoginException if the login failed
+139 * @throws IllegalArgumentException if the projectName is blank (null, empty or whitespace)
+140 */
+141publicRundeckProject getProject(String projectName) throws RundeckApiException, RundeckApiLoginException,
+142 IllegalArgumentException {
+143 AssertUtil.notBlank(projectName, "projectName is mandatory to get the details of a project !");
+144returnnewApiCall(this).get(newApiPathBuilder("/project/", projectName),
+145newProjectParser("result/projects/project"));
+146 }
+147
+148/*
+149 * Jobs
+150 */
+151
+152/**
+153 * List all jobs (for all projects)
+154 *
+155 * @return a {@link List} of {@link RundeckJob} : might be empty, but won't be null
+156 * @throws RundeckApiException in case of error when calling the API
+157 * @throws RundeckApiLoginException if the login failed
+158 */
+159public List<RundeckJob> getJobs() throws RundeckApiException, RundeckApiLoginException {
+160 List<RundeckJob> jobs = new ArrayList<RundeckJob>();
+161for (RundeckProject project : getProjects()) {
+162 jobs.addAll(getJobs(project.getName()));
+163 }
+164return jobs;
+165 }
+166
+167/**
+168 * List all jobs that belongs to the given project
+169 *
+170 * @param project name of the project - mandatory
+171 * @return a {@link List} of {@link RundeckJob} : might be empty, but won't be null
+172 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+173 * @throws RundeckApiLoginException if the login failed
+174 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
+175 * @see #getJobs(String, String, String, String...)
+176 */
+177public List<RundeckJob> getJobs(String project) throws RundeckApiException, RundeckApiLoginException,
+178 IllegalArgumentException {
+179return getJobs(project, null, null, new String[0]);
+180 }
+181
+182/**
+183 * List the jobs that belongs to the given project, and matches the given criteria (jobFilter, groupPath and jobIds)
+184 *
+185 * @param project name of the project - mandatory
+186 * @param jobFilter a filter for the job Name - optional
+187 * @param groupPath a group or partial group path to include all jobs within that group path - optional
+188 * @param jobIds a list of Job IDs to include - optional
+189 * @return a {@link List} of {@link RundeckJob} : might be empty, but won't be null
+190 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+191 * @throws RundeckApiLoginException if the login failed
+192 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
+193 * @see #getJobs(String)
+194 */
+195public List<RundeckJob> getJobs(String project, String jobFilter, String groupPath, String... jobIds)
+196throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+197 AssertUtil.notBlank(project, "project is mandatory to get all jobs !");
+198returnnewApiCall(this).get(newApiPathBuilder("/jobs").param("project", project)
+199 .param("jobFilter", jobFilter)
+200 .param("groupPath", groupPath)
+201 .param("idlist", StringUtils.join(jobIds, ",")),
+202new ListParser<RundeckJob>(newJobParser(), "result/jobs/job"));
+203 }
+204
+205/**
+206 * Export the definitions of all jobs that belongs to the given project, as an XML file
+207 *
+208 * @param filename path of the file where the content should be saved
+209 * @param project name of the project - mandatory
+210 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+211 * @throws RundeckApiLoginException if the login failed
+212 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
+213 * @throws IOException if we failed to write to the file
+214 * @see #exportJobsToFile(String, String, String, String, String...)
+215 * @see #exportJobs(String)
+216 */
+217publicvoid exportJobsToFile(String filename, String project) throws RundeckApiException, RundeckApiLoginException,
+218 IllegalArgumentException, IOException {
+219 exportJobsToFile(filename, project, null, null, new String[0]);
+220 }
+221
+222/**
+223 * Export the definitions of the jobs that belongs to the given project, and matches the given criteria (jobFilter,
+224 * groupPath and jobIds), as an XML file
+225 *
+226 * @param filename path of the file where the content should be saved
+227 * @param project name of the project - mandatory
+228 * @param jobFilter a filter for the job Name - optional
+229 * @param groupPath a group or partial group path to include all jobs within that group path - optional
+230 * @param jobIds a list of Job IDs to include - optional
+231 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+232 * @throws RundeckApiLoginException if the login failed
+233 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
+234 * @throws IOException if we failed to write to the file
+235 * @see #exportJobsToFile(String, String)
+236 * @see #exportJobs(String, String, String, String...)
+237 */
+238publicvoid exportJobsToFile(String filename, String project, String jobFilter, String groupPath, String... jobIds)
+239throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException, IOException {
+240 InputStream inputStream = exportJobs(project, jobFilter, groupPath, jobIds);
+241 FileUtils.writeByteArrayToFile(new File(filename), IOUtils.toByteArray(inputStream));
+242 }
+243
+244/**
+245 * Export the definitions of all jobs that belongs to the given project
+246 *
+247 * @param project name of the project - mandatory
+248 * @return an {@link InputStream} instance, not linked to any network resources - won't be null
+249 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+250 * @throws RundeckApiLoginException if the login failed
+251 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
+252 * @see #exportJobs(String, String, String, String...)
+253 * @see #exportJobsToFile(String, String)
+254 */
+255public InputStream exportJobs(String project) throws RundeckApiException, RundeckApiLoginException,
+256 IllegalArgumentException {
+257return exportJobs(project, null, null, new String[0]);
+258 }
+259
+260/**
+261 * Export the definitions of the jobs that belongs to the given project, and matches the given criteria (jobFilter,
+262 * groupPath and jobIds)
+263 *
+264 * @param project name of the project - mandatory
+265 * @param jobFilter a filter for the job Name - optional
+266 * @param groupPath a group or partial group path to include all jobs within that group path - optional
+267 * @param jobIds a list of Job IDs to include - optional
+268 * @return an {@link InputStream} instance, not linked to any network resources - won't be null
+269 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+270 * @throws RundeckApiLoginException if the login failed
+271 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
+272 * @see #exportJobs(String)
+273 * @see #exportJobsToFile(String, String, String, String, String...)
+274 */
+275public InputStream exportJobs(String project, String jobFilter, String groupPath, String... jobIds)
+276throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+277 AssertUtil.notBlank(project, "project is mandatory to export all jobs !");
+278returnnewApiCall(this).get(newApiPathBuilder("/jobs/export").param("project", project)
+279 .param("jobFilter", jobFilter)
+280 .param("groupPath", groupPath)
+281 .param("idlist", StringUtils.join(jobIds, ",")));
+282 }
+283
+284/**
+285 * Export the definition of a single job (identified by the given ID), as an XML file
+286 *
+287 * @param filename path of the file where the content should be saved
+288 * @param jobId identifier of the job - mandatory
+289 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+290 * @throws RundeckApiLoginException if the login failed
+291 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+292 * @throws IOException if we failed to write to the file
+293 * @see #exportJob(String)
+294 * @see #getJob(String)
+295 */
+296publicvoid exportJobToFile(String filename, String jobId) throws RundeckApiException, RundeckApiLoginException,
+297 IllegalArgumentException, IOException {
+298 InputStream inputStream = exportJob(jobId);
+299 FileUtils.writeByteArrayToFile(new File(filename), IOUtils.toByteArray(inputStream));
300 }
301302/**
-303 * Get the definition of a single job, identified by the given ID
+303 * Export the definition of a single job, identified by the given ID304 * 305 * @param jobId identifier of the job - mandatory
-306 * @return a {@link RundeckJob} instance - won't be null
+306 * @return an {@link InputStream} instance, not linked to any network resources - won't be null307 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)308 * @throws RundeckApiLoginException if the login failed309 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-310 */
-311publicRundeckJob getJob(String jobId) throws RundeckApiException, RundeckApiLoginException,
-312 IllegalArgumentException {
-313 AssertUtil.notBlank(jobId, "jobId is mandatory to get the details of a job !");
-314returnnewApiCall(this).get(newApiPathBuilder("/job/", jobId), newJobParser("joblist/job"));
-315 }
-316
-317/**
-318 * Delete a single job, identified by the given ID
-319 *
-320 * @param jobId identifier of the job - mandatory
-321 * @return the success message (note that in case of error, you'll get an exception)
-322 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-323 * @throws RundeckApiLoginException if the login failed
-324 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-325 */
-326public String deleteJob(String jobId) throws RundeckApiException, RundeckApiLoginException,
-327 IllegalArgumentException {
-328 AssertUtil.notBlank(jobId, "jobId is mandatory to delete a job !");
-329returnnewApiCall(this).delete(newApiPathBuilder("/job/", jobId), newStringParser("result/success/message"));
-330 }
-331
-332/**
-333 * Trigger the execution of a RunDeck job (identified by the given ID), and return immediately (without waiting the
-334 * end of the job execution)
-335 *
-336 * @param jobId identifier of the job - mandatory
-337 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
-338 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-339 * @throws RundeckApiLoginException if the login failed
-340 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-341 * @see #triggerJob(String, Properties, Properties)
-342 * @see #runJob(String)
-343 */
-344publicRundeckExecution triggerJob(String jobId) throws RundeckApiException, RundeckApiLoginException,
-345 IllegalArgumentException {
-346return triggerJob(jobId, null);
-347 }
-348
-349/**
-350 * Trigger the execution of a RunDeck job (identified by the given ID), and return immediately (without waiting the
-351 * end of the job execution)
-352 *
-353 * @param jobId identifier of the job - mandatory
-354 * @param options of the job - optional. See {@link OptionsBuilder}.
-355 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
-356 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-357 * @throws RundeckApiLoginException if the login failed
-358 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-359 * @see #triggerJob(String, Properties, Properties)
-360 * @see #runJob(String, Properties)
-361 */
-362publicRundeckExecution triggerJob(String jobId, Properties options) throws RundeckApiException,
-363 RundeckApiLoginException, IllegalArgumentException {
-364return triggerJob(jobId, options, null);
-365 }
-366
-367/**
-368 * Trigger the execution of a RunDeck job (identified by the given ID), and return immediately (without waiting the
-369 * end of the job execution)
-370 *
-371 * @param jobId identifier of the job - mandatory
-372 * @param options of the job - optional. See {@link OptionsBuilder}.
-373 * @param nodeFilters for overriding the nodes on which the job will be executed - optional. See
-374 * {@link NodeFiltersBuilder}
-375 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
-376 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-377 * @throws RundeckApiLoginException if the login failed
-378 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-379 * @see #triggerJob(String)
-380 * @see #runJob(String, Properties, Properties)
-381 */
-382publicRundeckExecution triggerJob(String jobId, Properties options, Properties nodeFilters)
-383throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
-384 AssertUtil.notBlank(jobId, "jobId is mandatory to trigger a job !");
-385returnnewApiCall(this).get(newApiPathBuilder("/job/", jobId, "/run").param("argString",
-386 ParametersUtil.generateArgString(options))
-387 .nodeFilters(nodeFilters),
-388newExecutionParser("result/executions/execution"));
-389 }
-390
-391/**
-392 * Run a RunDeck job (identified by the given ID), and wait until its execution is finished (or aborted) to return.
-393 * We will poll the RunDeck server at regular interval (every 5 seconds) to know if the execution is finished (or
-394 * aborted) or is still running.
-395 *
-396 * @param jobId identifier of the job - mandatory
-397 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
-398 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-399 * @throws RundeckApiLoginException if the login failed
-400 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-401 * @see #triggerJob(String)
-402 * @see #runJob(String, Properties, Properties, long, TimeUnit)
-403 */
-404publicRundeckExecution runJob(String jobId) throws RundeckApiException, RundeckApiLoginException,
-405 IllegalArgumentException {
-406return runJob(jobId, null);
-407 }
-408
-409/**
-410 * Run a RunDeck job (identified by the given ID), and wait until its execution is finished (or aborted) to return.
-411 * We will poll the RunDeck server at regular interval (every 5 seconds) to know if the execution is finished (or
-412 * aborted) or is still running.
-413 *
-414 * @param jobId identifier of the job - mandatory
-415 * @param options of the job - optional. See {@link OptionsBuilder}.
-416 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
-417 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-418 * @throws RundeckApiLoginException if the login failed
-419 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-420 * @see #triggerJob(String, Properties)
-421 * @see #runJob(String, Properties, Properties, long, TimeUnit)
-422 */
-423publicRundeckExecution runJob(String jobId, Properties options) throws RundeckApiException,
-424 RundeckApiLoginException, IllegalArgumentException {
-425return runJob(jobId, options, null);
-426 }
-427
-428/**
-429 * Run a RunDeck job (identified by the given ID), and wait until its execution is finished (or aborted) to return.
-430 * We will poll the RunDeck server at regular interval (every 5 seconds) to know if the execution is finished (or
-431 * aborted) or is still running.
-432 *
-433 * @param jobId identifier of the job - mandatory
-434 * @param options of the job - optional. See {@link OptionsBuilder}.
-435 * @param nodeFilters for overriding the nodes on which the job will be executed - optional. See
-436 * {@link NodeFiltersBuilder}
+310 * @see #exportJobToFile(String, String)
+311 * @see #getJob(String)
+312 */
+313public InputStream exportJob(String jobId) throws RundeckApiException, RundeckApiLoginException,
+314 IllegalArgumentException {
+315 AssertUtil.notBlank(jobId, "jobId is mandatory to get the details of a job !");
+316returnnewApiCall(this).get(newApiPathBuilder("/job/", jobId));
+317 }
+318
+319/**
+320 * Find a job, identified by its project, group and name. Note that the groupPath is optional, as a job does not
+321 * need to belong to a group (either pass null, or an empty string).
+322 *
+323 * @param project name of the project - mandatory
+324 * @param groupPath group to which the job belongs (if it belongs to a group) - optional
+325 * @param name of the job to find - mandatory
+326 * @return a {@link RundeckJob} instance - null if not found
+327 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+328 * @throws RundeckApiLoginException if the login failed
+329 * @throws IllegalArgumentException if the project or the name is blank (null, empty or whitespace)
+330 * @see #getJob(String)
+331 */
+332publicRundeckJob findJob(String project, String groupPath, String name) throws RundeckApiException,
+333 RundeckApiLoginException, IllegalArgumentException {
+334 AssertUtil.notBlank(project, "project is mandatory to find a job !");
+335 AssertUtil.notBlank(name, "job name is mandatory to find a job !");
+336 List<RundeckJob> jobs = getJobs(project, name, groupPath, new String[0]);
+337return jobs.isEmpty() ? null : jobs.get(0);
+338 }
+339
+340/**
+341 * Get the definition of a single job, identified by the given ID
+342 *
+343 * @param jobId identifier of the job - mandatory
+344 * @return a {@link RundeckJob} instance - won't be null
+345 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+346 * @throws RundeckApiLoginException if the login failed
+347 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+348 * @see #findJob(String, String, String)
+349 * @see #exportJob(String)
+350 */
+351publicRundeckJob getJob(String jobId) throws RundeckApiException, RundeckApiLoginException,
+352 IllegalArgumentException {
+353 AssertUtil.notBlank(jobId, "jobId is mandatory to get the details of a job !");
+354returnnewApiCall(this).get(newApiPathBuilder("/job/", jobId), newJobParser("joblist/job"));
+355 }
+356
+357/**
+358 * Delete a single job, identified by the given ID
+359 *
+360 * @param jobId identifier of the job - mandatory
+361 * @return the success message (note that in case of error, you'll get an exception)
+362 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+363 * @throws RundeckApiLoginException if the login failed
+364 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+365 */
+366public String deleteJob(String jobId) throws RundeckApiException, RundeckApiLoginException,
+367 IllegalArgumentException {
+368 AssertUtil.notBlank(jobId, "jobId is mandatory to delete a job !");
+369returnnewApiCall(this).delete(newApiPathBuilder("/job/", jobId), newStringParser("result/success/message"));
+370 }
+371
+372/**
+373 * Trigger the execution of a RunDeck job (identified by the given ID), and return immediately (without waiting the
+374 * end of the job execution)
+375 *
+376 * @param jobId identifier of the job - mandatory
+377 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
+378 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+379 * @throws RundeckApiLoginException if the login failed
+380 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+381 * @see #triggerJob(String, Properties, Properties)
+382 * @see #runJob(String)
+383 */
+384publicRundeckExecution triggerJob(String jobId) throws RundeckApiException, RundeckApiLoginException,
+385 IllegalArgumentException {
+386return triggerJob(jobId, null);
+387 }
+388
+389/**
+390 * Trigger the execution of a RunDeck job (identified by the given ID), and return immediately (without waiting the
+391 * end of the job execution)
+392 *
+393 * @param jobId identifier of the job - mandatory
+394 * @param options of the job - optional. See {@link OptionsBuilder}.
+395 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
+396 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+397 * @throws RundeckApiLoginException if the login failed
+398 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+399 * @see #triggerJob(String, Properties, Properties)
+400 * @see #runJob(String, Properties)
+401 */
+402publicRundeckExecution triggerJob(String jobId, Properties options) throws RundeckApiException,
+403 RundeckApiLoginException, IllegalArgumentException {
+404return triggerJob(jobId, options, null);
+405 }
+406
+407/**
+408 * Trigger the execution of a RunDeck job (identified by the given ID), and return immediately (without waiting the
+409 * end of the job execution)
+410 *
+411 * @param jobId identifier of the job - mandatory
+412 * @param options of the job - optional. See {@link OptionsBuilder}.
+413 * @param nodeFilters for overriding the nodes on which the job will be executed - optional. See
+414 * {@link NodeFiltersBuilder}
+415 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
+416 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+417 * @throws RundeckApiLoginException if the login failed
+418 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+419 * @see #triggerJob(String)
+420 * @see #runJob(String, Properties, Properties)
+421 */
+422publicRundeckExecution triggerJob(String jobId, Properties options, Properties nodeFilters)
+423throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+424 AssertUtil.notBlank(jobId, "jobId is mandatory to trigger a job !");
+425returnnewApiCall(this).get(newApiPathBuilder("/job/", jobId, "/run").param("argString",
+426 ParametersUtil.generateArgString(options))
+427 .nodeFilters(nodeFilters),
+428newExecutionParser("result/executions/execution"));
+429 }
+430
+431/**
+432 * Run a RunDeck job (identified by the given ID), and wait until its execution is finished (or aborted) to return.
+433 * We will poll the RunDeck server at regular interval (every 5 seconds) to know if the execution is finished (or
+434 * aborted) or is still running.
+435 *
+436 * @param jobId identifier of the job - mandatory437 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null438 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)439 * @throws RundeckApiLoginException if the login failed440 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-441 * @see #triggerJob(String, Properties, Properties)
+441 * @see #triggerJob(String)442 * @see #runJob(String, Properties, Properties, long, TimeUnit)443 */
-444publicRundeckExecution runJob(String jobId, Properties options, Properties nodeFilters)
-445throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
-446return runJob(jobId, options, nodeFilters, 5, TimeUnit.SECONDS);
+444publicRundeckExecution runJob(String jobId) throws RundeckApiException, RundeckApiLoginException,
+445 IllegalArgumentException {
+446return runJob(jobId, null);
447 }
448449/**450 * Run a RunDeck job (identified by the given ID), and wait until its execution is finished (or aborted) to return.
-451 * We will poll the RunDeck server at regular interval (configured by the poolingInterval/poolingUnit couple) to
-452 * know if the execution is finished (or aborted) or is still running.
+451 * We will poll the RunDeck server at regular interval (every 5 seconds) to know if the execution is finished (or
+452 * aborted) or is still running.453 * 454 * @param jobId identifier of the job - mandatory455 * @param options of the job - optional. See {@link OptionsBuilder}.
-456 * @param poolingInterval for checking the status of the execution. Must be > 0.
-457 * @param poolingUnit unit (seconds, milli-seconds, ...) of the interval. Default to seconds.
-458 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
-459 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-460 * @throws RundeckApiLoginException if the login failed
-461 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-462 * @see #triggerJob(String, Properties)
-463 * @see #runJob(String, Properties, Properties, long, TimeUnit)
-464 */
-465publicRundeckExecution runJob(String jobId, Properties options, long poolingInterval, TimeUnit poolingUnit)
-466throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
-467return runJob(jobId, options, null, poolingInterval, poolingUnit);
-468 }
-469
-470/**
-471 * Run a RunDeck job (identified by the given ID), and wait until its execution is finished (or aborted) to return.
-472 * We will poll the RunDeck server at regular interval (configured by the poolingInterval/poolingUnit couple) to
-473 * know if the execution is finished (or aborted) or is still running.
-474 *
-475 * @param jobId identifier of the job - mandatory
-476 * @param options of the job - optional. See {@link OptionsBuilder}.
-477 * @param nodeFilters for overriding the nodes on which the job will be executed - optional. See
-478 * {@link NodeFiltersBuilder}
-479 * @param poolingInterval for checking the status of the execution. Must be > 0.
-480 * @param poolingUnit unit (seconds, milli-seconds, ...) of the interval. Default to seconds.
-481 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
-482 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-483 * @throws RundeckApiLoginException if the login failed
-484 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-485 * @see #triggerJob(String, Properties)
-486 * @see #runJob(String, Properties, Properties, long, TimeUnit)
-487 */
-488publicRundeckExecution runJob(String jobId, Properties options, Properties nodeFilters, long poolingInterval,
-489 TimeUnit poolingUnit) throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
-490if (poolingInterval <= 0) {
-491 poolingInterval = 5;
-492 poolingUnit = TimeUnit.SECONDS;
-493 }
-494if (poolingUnit == null) {
-495 poolingUnit = TimeUnit.SECONDS;
-496 }
-497
-498RundeckExecution execution = triggerJob(jobId, options, nodeFilters);
-499while (ExecutionStatus.RUNNING.equals(execution.getStatus())) {
-500try {
-501 Thread.sleep(poolingUnit.toMillis(poolingInterval));
-502 } catch (InterruptedException e) {
-503break;
-504 }
-505 execution = getExecution(execution.getId());
-506 }
-507return execution;
+456 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
+457 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+458 * @throws RundeckApiLoginException if the login failed
+459 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+460 * @see #triggerJob(String, Properties)
+461 * @see #runJob(String, Properties, Properties, long, TimeUnit)
+462 */
+463publicRundeckExecution runJob(String jobId, Properties options) throws RundeckApiException,
+464 RundeckApiLoginException, IllegalArgumentException {
+465return runJob(jobId, options, null);
+466 }
+467
+468/**
+469 * Run a RunDeck job (identified by the given ID), and wait until its execution is finished (or aborted) to return.
+470 * We will poll the RunDeck server at regular interval (every 5 seconds) to know if the execution is finished (or
+471 * aborted) or is still running.
+472 *
+473 * @param jobId identifier of the job - mandatory
+474 * @param options of the job - optional. See {@link OptionsBuilder}.
+475 * @param nodeFilters for overriding the nodes on which the job will be executed - optional. See
+476 * {@link NodeFiltersBuilder}
+477 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
+478 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+479 * @throws RundeckApiLoginException if the login failed
+480 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+481 * @see #triggerJob(String, Properties, Properties)
+482 * @see #runJob(String, Properties, Properties, long, TimeUnit)
+483 */
+484publicRundeckExecution runJob(String jobId, Properties options, Properties nodeFilters)
+485throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+486return runJob(jobId, options, nodeFilters, 5, TimeUnit.SECONDS);
+487 }
+488
+489/**
+490 * Run a RunDeck job (identified by the given ID), and wait until its execution is finished (or aborted) to return.
+491 * We will poll the RunDeck server at regular interval (configured by the poolingInterval/poolingUnit couple) to
+492 * know if the execution is finished (or aborted) or is still running.
+493 *
+494 * @param jobId identifier of the job - mandatory
+495 * @param options of the job - optional. See {@link OptionsBuilder}.
+496 * @param poolingInterval for checking the status of the execution. Must be > 0.
+497 * @param poolingUnit unit (seconds, milli-seconds, ...) of the interval. Default to seconds.
+498 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
+499 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+500 * @throws RundeckApiLoginException if the login failed
+501 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+502 * @see #triggerJob(String, Properties)
+503 * @see #runJob(String, Properties, Properties, long, TimeUnit)
+504 */
+505publicRundeckExecution runJob(String jobId, Properties options, long poolingInterval, TimeUnit poolingUnit)
+506throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+507return runJob(jobId, options, null, poolingInterval, poolingUnit);
508 }
509
-510/*
-511 * Ad-hoc commands
-512 */
-513
-514/**
-515 * Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
-516 * The command will not be dispatched to nodes, but be executed on the RunDeck server.
-517 *
-518 * @param project name of the project - mandatory
-519 * @param command to be executed - mandatory
-520 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
-521 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-522 * @throws RundeckApiLoginException if the login failed
-523 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
-524 * @see #triggerAdhocCommand(String, String, Properties)
-525 * @see #runAdhocCommand(String, String)
-526 */
-527publicRundeckExecution triggerAdhocCommand(String project, String command) throws RundeckApiException,
-528 RundeckApiLoginException, IllegalArgumentException {
-529return triggerAdhocCommand(project, command, null);
-530 }
-531
-532/**
-533 * Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
-534 * The command will be dispatched to nodes, accordingly to the nodeFilters parameter.
-535 *
-536 * @param project name of the project - mandatory
-537 * @param command to be executed - mandatory
-538 * @param nodeFilters for selecting nodes on which the command will be executed. See {@link NodeFiltersBuilder}
-539 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
-540 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-541 * @throws RundeckApiLoginException if the login failed
-542 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
-543 * @see #triggerAdhocCommand(String, String)
-544 * @see #runAdhocCommand(String, String, Properties)
-545 */
-546publicRundeckExecution triggerAdhocCommand(String project, String command, Properties nodeFilters)
-547throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
-548 AssertUtil.notBlank(project, "project is mandatory to trigger an ad-hoc command !");
-549 AssertUtil.notBlank(command, "command is mandatory to trigger an ad-hoc command !");
-550RundeckExecution execution = newApiCall(this).get(newApiPathBuilder("/run/command").param("project", project)
-551 .param("exec", command)
-552 .nodeFilters(nodeFilters),
-553newExecutionParser("result/execution"));
-554// the first call just returns the ID of the execution, so we need another call to get a "real" execution
-555return getExecution(execution.getId());
-556 }
-557
-558/**
-559 * Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
-560 * server at regular interval (every 5 seconds) to know if the execution is finished (or aborted) or is still
-561 * running. The command will not be dispatched to nodes, but be executed on the RunDeck server.
-562 *
-563 * @param project name of the project - mandatory
-564 * @param command to be executed - mandatory
-565 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
-566 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-567 * @throws RundeckApiLoginException if the login failed
-568 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
-569 * @see #runAdhocCommand(String, String, Properties, long, TimeUnit)
-570 * @see #triggerAdhocCommand(String, String)
-571 */
-572publicRundeckExecution runAdhocCommand(String project, String command) throws RundeckApiException,
-573 RundeckApiLoginException, IllegalArgumentException {
-574return runAdhocCommand(project, command, null);
-575 }
-576
-577/**
-578 * Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
-579 * server at regular interval (configured by the poolingInterval/poolingUnit couple) to know if the execution is
-580 * finished (or aborted) or is still running. The command will not be dispatched to nodes, but be executed on the
-581 * RunDeck server.
-582 *
-583 * @param project name of the project - mandatory
-584 * @param command to be executed - mandatory
-585 * @param poolingInterval for checking the status of the execution. Must be > 0.
-586 * @param poolingUnit unit (seconds, milli-seconds, ...) of the interval. Default to seconds.
-587 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
-588 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-589 * @throws RundeckApiLoginException if the login failed
-590 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
-591 * @see #runAdhocCommand(String, String, Properties, long, TimeUnit)
-592 * @see #triggerAdhocCommand(String, String)
-593 */
-594publicRundeckExecution runAdhocCommand(String project, String command, long poolingInterval, TimeUnit poolingUnit)
-595throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
-596return runAdhocCommand(project, command, null, poolingInterval, poolingUnit);
-597 }
-598
-599/**
-600 * Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
-601 * server at regular interval (every 5 seconds) to know if the execution is finished (or aborted) or is still
-602 * running. The command will be dispatched to nodes, accordingly to the nodeFilters parameter.
-603 *
-604 * @param project name of the project - mandatory
-605 * @param command to be executed - mandatory
-606 * @param nodeFilters for selecting nodes on which the command will be executed. See {@link NodeFiltersBuilder}
-607 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
-608 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-609 * @throws RundeckApiLoginException if the login failed
-610 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
-611 * @see #runAdhocCommand(String, String, Properties, long, TimeUnit)
-612 * @see #triggerAdhocCommand(String, String, Properties)
-613 */
-614publicRundeckExecution runAdhocCommand(String project, String command, Properties nodeFilters)
-615throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
-616return runAdhocCommand(project, command, nodeFilters, 5, TimeUnit.SECONDS);
-617 }
-618
-619/**
-620 * Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
-621 * server at regular interval (configured by the poolingInterval/poolingUnit couple) to know if the execution is
-622 * finished (or aborted) or is still running. The command will be dispatched to nodes, accordingly to the
-623 * nodeFilters parameter.
-624 *
-625 * @param project name of the project - mandatory
-626 * @param command to be executed - mandatory
-627 * @param nodeFilters for selecting nodes on which the command will be executed. See {@link NodeFiltersBuilder}
-628 * @param poolingInterval for checking the status of the execution. Must be > 0.
-629 * @param poolingUnit unit (seconds, milli-seconds, ...) of the interval. Default to seconds.
-630 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
-631 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-632 * @throws RundeckApiLoginException if the login failed
-633 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
-634 * @see #triggerAdhocCommand(String, String, Properties)
-635 */
-636publicRundeckExecution runAdhocCommand(String project, String command, Properties nodeFilters,
-637long poolingInterval, TimeUnit poolingUnit) throws RundeckApiException, RundeckApiLoginException,
-638 IllegalArgumentException {
-639if (poolingInterval <= 0) {
-640 poolingInterval = 5;
-641 poolingUnit = TimeUnit.SECONDS;
-642 }
-643if (poolingUnit == null) {
-644 poolingUnit = TimeUnit.SECONDS;
-645 }
-646
-647RundeckExecution execution = triggerAdhocCommand(project, command, nodeFilters);
-648while (ExecutionStatus.RUNNING.equals(execution.getStatus())) {
-649try {
-650 Thread.sleep(poolingUnit.toMillis(poolingInterval));
-651 } catch (InterruptedException e) {
-652break;
-653 }
-654 execution = getExecution(execution.getId());
-655 }
-656return execution;
-657 }
-658
-659/*
-660 * Executions
-661 */
-662
-663/**
-664 * Get all running executions (for all projects)
-665 *
-666 * @return a {@link List} of {@link RundeckExecution} : might be empty, but won't be null
-667 * @throws RundeckApiException in case of error when calling the API
-668 * @throws RundeckApiLoginException if the login failed
-669 */
-670public List<RundeckExecution> getRunningExecutions() throws RundeckApiException, RundeckApiLoginException {
-671 List<RundeckExecution> executions = new ArrayList<RundeckExecution>();
-672for (RundeckProject project : getProjects()) {
-673 executions.addAll(getRunningExecutions(project.getName()));
-674 }
-675return executions;
-676 }
-677
-678/**
-679 * Get the running executions for the given project
-680 *
-681 * @param project name of the project - mandatory
-682 * @return a {@link List} of {@link RundeckExecution} : might be empty, but won't be null
-683 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-684 * @throws RundeckApiLoginException if the login failed
-685 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
-686 */
-687public List<RundeckExecution> getRunningExecutions(String project) throws RundeckApiException,
-688 RundeckApiLoginException, IllegalArgumentException {
-689 AssertUtil.notBlank(project, "project is mandatory get all running executions !");
-690returnnewApiCall(this).get(newApiPathBuilder("/executions/running").param("project", project),
-691new ListParser<RundeckExecution>(newExecutionParser(),
-692"result/executions/execution"));
-693 }
-694
-695/**
-696 * Get the executions of the given job
-697 *
-698 * @param jobId identifier of the job - mandatory
-699 * @return a {@link List} of {@link RundeckExecution} : might be empty, but won't be null
-700 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-701 * @throws RundeckApiLoginException if the login failed
-702 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-703 */
-704public List<RundeckExecution> getJobExecutions(String jobId) throws RundeckApiException, RundeckApiLoginException,
+510/**
+511 * Run a RunDeck job (identified by the given ID), and wait until its execution is finished (or aborted) to return.
+512 * We will poll the RunDeck server at regular interval (configured by the poolingInterval/poolingUnit couple) to
+513 * know if the execution is finished (or aborted) or is still running.
+514 *
+515 * @param jobId identifier of the job - mandatory
+516 * @param options of the job - optional. See {@link OptionsBuilder}.
+517 * @param nodeFilters for overriding the nodes on which the job will be executed - optional. See
+518 * {@link NodeFiltersBuilder}
+519 * @param poolingInterval for checking the status of the execution. Must be > 0.
+520 * @param poolingUnit unit (seconds, milli-seconds, ...) of the interval. Default to seconds.
+521 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
+522 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+523 * @throws RundeckApiLoginException if the login failed
+524 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+525 * @see #triggerJob(String, Properties)
+526 * @see #runJob(String, Properties, Properties, long, TimeUnit)
+527 */
+528publicRundeckExecution runJob(String jobId, Properties options, Properties nodeFilters, long poolingInterval,
+529 TimeUnit poolingUnit) throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+530if (poolingInterval <= 0) {
+531 poolingInterval = 5;
+532 poolingUnit = TimeUnit.SECONDS;
+533 }
+534if (poolingUnit == null) {
+535 poolingUnit = TimeUnit.SECONDS;
+536 }
+537
+538RundeckExecution execution = triggerJob(jobId, options, nodeFilters);
+539while (ExecutionStatus.RUNNING.equals(execution.getStatus())) {
+540try {
+541 Thread.sleep(poolingUnit.toMillis(poolingInterval));
+542 } catch (InterruptedException e) {
+543break;
+544 }
+545 execution = getExecution(execution.getId());
+546 }
+547return execution;
+548 }
+549
+550/*
+551 * Ad-hoc commands
+552 */
+553
+554/**
+555 * Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
+556 * The command will not be dispatched to nodes, but be executed on the RunDeck server.
+557 *
+558 * @param project name of the project - mandatory
+559 * @param command to be executed - mandatory
+560 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
+561 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+562 * @throws RundeckApiLoginException if the login failed
+563 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
+564 * @see #triggerAdhocCommand(String, String, Properties, Integer, Boolean)
+565 * @see #runAdhocCommand(String, String)
+566 */
+567publicRundeckExecution triggerAdhocCommand(String project, String command) throws RundeckApiException,
+568 RundeckApiLoginException, IllegalArgumentException {
+569return triggerAdhocCommand(project, command, null);
+570 }
+571
+572/**
+573 * Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
+574 * The command will be dispatched to nodes, accordingly to the nodeFilters parameter.
+575 *
+576 * @param project name of the project - mandatory
+577 * @param command to be executed - mandatory
+578 * @param nodeFilters for selecting nodes on which the command will be executed. See {@link NodeFiltersBuilder}
+579 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
+580 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+581 * @throws RundeckApiLoginException if the login failed
+582 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
+583 * @see #triggerAdhocCommand(String, String, Properties, Integer, Boolean)
+584 * @see #runAdhocCommand(String, String, Properties)
+585 */
+586publicRundeckExecution triggerAdhocCommand(String project, String command, Properties nodeFilters)
+587throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+588return triggerAdhocCommand(project, command, nodeFilters, null, null);
+589 }
+590
+591/**
+592 * Trigger the execution of an ad-hoc command, and return immediately (without waiting the end of the execution).
+593 * The command will be dispatched to nodes, accordingly to the nodeFilters parameter.
+594 *
+595 * @param project name of the project - mandatory
+596 * @param command to be executed - mandatory
+597 * @param nodeFilters for selecting nodes on which the command will be executed. See {@link NodeFiltersBuilder}
+598 * @param nodeThreadcount thread count to use (for parallelizing when running on multiple nodes) - optional
+599 * @param nodeKeepgoing if true, continue executing on other nodes even if some fail - optional
+600 * @return a {@link RundeckExecution} instance for the newly created (and running) execution - won't be null
+601 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+602 * @throws RundeckApiLoginException if the login failed
+603 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
+604 * @see #triggerAdhocCommand(String, String)
+605 * @see #runAdhocCommand(String, String, Properties)
+606 */
+607publicRundeckExecution triggerAdhocCommand(String project, String command, Properties nodeFilters,
+608 Integer nodeThreadcount, Boolean nodeKeepgoing) throws RundeckApiException, RundeckApiLoginException,
+609 IllegalArgumentException {
+610 AssertUtil.notBlank(project, "project is mandatory to trigger an ad-hoc command !");
+611 AssertUtil.notBlank(command, "command is mandatory to trigger an ad-hoc command !");
+612RundeckExecution execution = newApiCall(this).get(newApiPathBuilder("/run/command").param("project", project)
+613 .param("exec", command)
+614 .param("nodeThreadcount",
+615 nodeThreadcount)
+616 .param("nodeKeepgoing",
+617 nodeKeepgoing)
+618 .nodeFilters(nodeFilters),
+619newExecutionParser("result/execution"));
+620// the first call just returns the ID of the execution, so we need another call to get a "real" execution
+621return getExecution(execution.getId());
+622 }
+623
+624/**
+625 * Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
+626 * server at regular interval (every 5 seconds) to know if the execution is finished (or aborted) or is still
+627 * running. The command will not be dispatched to nodes, but be executed on the RunDeck server.
+628 *
+629 * @param project name of the project - mandatory
+630 * @param command to be executed - mandatory
+631 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
+632 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+633 * @throws RundeckApiLoginException if the login failed
+634 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
+635 * @see #runAdhocCommand(String, String, Properties, Integer, Boolean, long, TimeUnit)
+636 * @see #triggerAdhocCommand(String, String)
+637 */
+638publicRundeckExecution runAdhocCommand(String project, String command) throws RundeckApiException,
+639 RundeckApiLoginException, IllegalArgumentException {
+640return runAdhocCommand(project, command, null);
+641 }
+642
+643/**
+644 * Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
+645 * server at regular interval (configured by the poolingInterval/poolingUnit couple) to know if the execution is
+646 * finished (or aborted) or is still running. The command will not be dispatched to nodes, but be executed on the
+647 * RunDeck server.
+648 *
+649 * @param project name of the project - mandatory
+650 * @param command to be executed - mandatory
+651 * @param poolingInterval for checking the status of the execution. Must be > 0.
+652 * @param poolingUnit unit (seconds, milli-seconds, ...) of the interval. Default to seconds.
+653 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
+654 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+655 * @throws RundeckApiLoginException if the login failed
+656 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
+657 * @see #runAdhocCommand(String, String, Properties, Integer, Boolean, long, TimeUnit)
+658 * @see #triggerAdhocCommand(String, String)
+659 */
+660publicRundeckExecution runAdhocCommand(String project, String command, long poolingInterval, TimeUnit poolingUnit)
+661throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+662return runAdhocCommand(project, command, null, poolingInterval, poolingUnit);
+663 }
+664
+665/**
+666 * Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
+667 * server at regular interval (every 5 seconds) to know if the execution is finished (or aborted) or is still
+668 * running. The command will be dispatched to nodes, accordingly to the nodeFilters parameter.
+669 *
+670 * @param project name of the project - mandatory
+671 * @param command to be executed - mandatory
+672 * @param nodeFilters for selecting nodes on which the command will be executed. See {@link NodeFiltersBuilder}
+673 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
+674 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+675 * @throws RundeckApiLoginException if the login failed
+676 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
+677 * @see #runAdhocCommand(String, String, Properties, Integer, Boolean, long, TimeUnit)
+678 * @see #triggerAdhocCommand(String, String, Properties)
+679 */
+680publicRundeckExecution runAdhocCommand(String project, String command, Properties nodeFilters)
+681throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+682return runAdhocCommand(project, command, nodeFilters, null, null);
+683 }
+684
+685/**
+686 * Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
+687 * server at regular interval (configured by the poolingInterval/poolingUnit couple) to know if the execution is
+688 * finished (or aborted) or is still running. The command will be dispatched to nodes, accordingly to the
+689 * nodeFilters parameter.
+690 *
+691 * @param project name of the project - mandatory
+692 * @param command to be executed - mandatory
+693 * @param nodeFilters for selecting nodes on which the command will be executed. See {@link NodeFiltersBuilder}
+694 * @param poolingInterval for checking the status of the execution. Must be > 0.
+695 * @param poolingUnit unit (seconds, milli-seconds, ...) of the interval. Default to seconds.
+696 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
+697 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+698 * @throws RundeckApiLoginException if the login failed
+699 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
+700 * @see #runAdhocCommand(String, String, Properties, Integer, Boolean, long, TimeUnit)
+701 * @see #triggerAdhocCommand(String, String, Properties)
+702 */
+703publicRundeckExecution runAdhocCommand(String project, String command, Properties nodeFilters,
+704long poolingInterval, TimeUnit poolingUnit) throws RundeckApiException, RundeckApiLoginException,
705 IllegalArgumentException {
-706return getJobExecutions(jobId, null);
+706return runAdhocCommand(project, command, nodeFilters, null, null, poolingInterval, poolingUnit);
707 }
708709/**
-710 * Get the executions of the given job
-711 *
-712 * @param jobId identifier of the job - mandatory
-713 * @param status of the executions - optional (null for all)
-714 * @return a {@link List} of {@link RundeckExecution} : might be empty, but won't be null
-715 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-716 * @throws RundeckApiLoginException if the login failed
-717 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-718 */
-719public List<RundeckExecution> getJobExecutions(String jobId, ExecutionStatus status) throws RundeckApiException,
-720 RundeckApiLoginException, IllegalArgumentException {
-721return getJobExecutions(jobId, status, null, null);
-722 }
-723
-724/**
-725 * Get the executions of the given job
-726 *
-727 * @param jobId identifier of the job - mandatory
-728 * @param status of the executions - optional (null for all)
-729 * @param max number of results to return - optional (null for all)
-730 * @param offset the 0-indexed offset for the first result to return - optional
-731 * @return a {@link List} of {@link RundeckExecution} : might be empty, but won't be null
-732 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
-733 * @throws RundeckApiLoginException if the login failed
-734 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
-735 */
-736public List<RundeckExecution> getJobExecutions(String jobId, ExecutionStatus status, Long max, Long offset)
-737throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
-738 AssertUtil.notBlank(jobId, "jobId is mandatory to get the executions of a job !");
-739returnnewApiCall(this).get(newApiPathBuilder("/job/", jobId, "/executions").param("status",
-740 status != null ? StringUtils.lowerCase(status.toString()) : null)
-741 .param("max", max)
-742 .param("offset", offset),
-743new ListParser<RundeckExecution>(newExecutionParser(),
-744"result/executions/execution"));
-745 }
-746
-747/**
-748 * Get a single execution, identified by the given ID
-749 *
-750 * @param executionId identifier of the execution - mandatory
-751 * @return a {@link RundeckExecution} instance - won't be null
-752 * @throws RundeckApiException in case of error when calling the API (non-existent execution with this ID)
-753 * @throws RundeckApiLoginException if the login failed
-754 * @throws IllegalArgumentException if the executionId is null
-755 */
-756publicRundeckExecution getExecution(Long executionId) throws RundeckApiException, RundeckApiLoginException,
-757 IllegalArgumentException {
-758 AssertUtil.notNull(executionId, "executionId is mandatory to get the details of an execution !");
-759returnnewApiCall(this).get(newApiPathBuilder("/execution/", executionId.toString()),
-760newExecutionParser("result/executions/execution"));
-761 }
-762
-763/**
-764 * Abort an execution (identified by the given ID). The execution should be running...
-765 *
-766 * @param executionId identifier of the execution - mandatory
-767 * @return a {@link RundeckAbort} instance - won't be null
-768 * @throws RundeckApiException in case of error when calling the API (non-existent execution with this ID)
-769 * @throws RundeckApiLoginException if the login failed
-770 * @throws IllegalArgumentException if the executionId is null
-771 */
-772publicRundeckAbort abortExecution(Long executionId) throws RundeckApiException, RundeckApiLoginException,
-773 IllegalArgumentException {
-774 AssertUtil.notNull(executionId, "executionId is mandatory to abort an execution !");
-775returnnewApiCall(this).get(newApiPathBuilder("/execution/", executionId.toString(), "/abort"),
-776newAbortParser("result/abort"));
-777 }
-778
-779/*
-780 * Nodes
-781 */
-782
-783/**
-784 * List all nodes (for all projects)
-785 *
-786 * @return a {@link List} of {@link RundeckNode} : might be empty, but won't be null
-787 * @throws RundeckApiException in case of error when calling the API
-788 * @throws RundeckApiLoginException if the login failed
-789 */
-790public List<RundeckNode> getNodes() throws RundeckApiException, RundeckApiLoginException {
-791 List<RundeckNode> nodes = new ArrayList<RundeckNode>();
-792for (RundeckProject project : getProjects()) {
-793 nodes.addAll(getNodes(project.getName()));
-794 }
-795return nodes;
-796 }
-797
-798/**
-799 * List all nodes that belongs to the given project
-800 *
-801 * @param project name of the project - mandatory
-802 * @return a {@link List} of {@link RundeckNode} : might be empty, but won't be null
-803 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-804 * @throws RundeckApiLoginException if the login failed
-805 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
-806 * @see #getNodes(String, Properties)
-807 */
-808public List<RundeckNode> getNodes(String project) throws RundeckApiException, RundeckApiLoginException,
-809 IllegalArgumentException {
-810return getNodes(project, null);
-811 }
-812
-813/**
-814 * List nodes that belongs to the given project
-815 *
-816 * @param project name of the project - mandatory
-817 * @param nodeFilters for filtering the nodes - optional. See {@link NodeFiltersBuilder}
-818 * @return a {@link List} of {@link RundeckNode} : might be empty, but won't be null
-819 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
-820 * @throws RundeckApiLoginException if the login failed
-821 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
-822 */
-823public List<RundeckNode> getNodes(String project, Properties nodeFilters) throws RundeckApiException,
-824 RundeckApiLoginException, IllegalArgumentException {
-825 AssertUtil.notBlank(project, "project is mandatory to get all nodes !");
-826returnnewApiCall(this).get(newApiPathBuilder("/resources").param("project", project)
-827 .nodeFilters(nodeFilters),
-828new ListParser<RundeckNode>(newNodeParser(), "project/node"));
-829 }
-830
-831/**
-832 * Get the definition of a single node
-833 *
-834 * @param name of the node - mandatory
-835 * @param project name of the project - mandatory
-836 * @return a {@link RundeckNode} instance - won't be null
-837 * @throws RundeckApiException in case of error when calling the API (non-existent name or project with this name)
-838 * @throws RundeckApiLoginException if the login failed
-839 * @throws IllegalArgumentException if the name or project is blank (null, empty or whitespace)
-840 */
-841publicRundeckNode getNode(String name, String project) throws RundeckApiException, RundeckApiLoginException,
-842 IllegalArgumentException {
-843 AssertUtil.notBlank(name, "the name of the node is mandatory to get a node !");
-844 AssertUtil.notBlank(project, "project is mandatory to get a node !");
-845returnnewApiCall(this).get(newApiPathBuilder("/resource/", name).param("project", project),
-846newNodeParser("project/node"));
-847 }
-848
-849public String getUrl() {
-850return url;
-851 }
-852
-853public String getLogin() {
-854return login;
-855 }
-856
-857public String getPassword() {
-858return password;
-859 }
-860
-861 @Override
-862public String toString() {
-863return"RundeckClient [url=" + url + ", login=" + login + ", password=" + password + "]";
-864 }
-865
-866 @Override
-867publicint hashCode() {
-868finalint prime = 31;
-869int result = 1;
-870 result = prime * result + ((login == null) ? 0 : login.hashCode());
-871 result = prime * result + ((password == null) ? 0 : password.hashCode());
-872 result = prime * result + ((url == null) ? 0 : url.hashCode());
-873return result;
-874 }
-875
-876 @Override
-877publicboolean equals(Object obj) {
-878if (this == obj)
-879returntrue;
-880if (obj == null)
-881return false;
-882if (getClass() != obj.getClass())
-883return false;
-884RundeckClient other = (RundeckClient) obj;
-885if (login == null) {
-886if (other.login != null)
-887return false;
-888 } elseif (!login.equals(other.login))
-889return false;
-890if (password == null) {
-891if (other.password != null)
-892return false;
-893 } elseif (!password.equals(other.password))
-894return false;
-895if (url == null) {
-896if (other.url != null)
-897return false;
-898 } elseif (!url.equals(other.url))
-899return false;
-900returntrue;
-901 }
-902
-903 }
+710 * Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
+711 * server at regular interval (every 5 seconds) to know if the execution is finished (or aborted) or is still
+712 * running. The command will be dispatched to nodes, accordingly to the nodeFilters parameter.
+713 *
+714 * @param project name of the project - mandatory
+715 * @param command to be executed - mandatory
+716 * @param nodeFilters for selecting nodes on which the command will be executed. See {@link NodeFiltersBuilder}
+717 * @param nodeThreadcount thread count to use (for parallelizing when running on multiple nodes) - optional
+718 * @param nodeKeepgoing if true, continue executing on other nodes even if some fail - optional
+719 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
+720 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+721 * @throws RundeckApiLoginException if the login failed
+722 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
+723 * @see #runAdhocCommand(String, String, Properties, Integer, Boolean, long, TimeUnit)
+724 * @see #triggerAdhocCommand(String, String, Properties, Integer, Boolean)
+725 */
+726publicRundeckExecution runAdhocCommand(String project, String command, Properties nodeFilters,
+727 Integer nodeThreadcount, Boolean nodeKeepgoing) throws RundeckApiException, RundeckApiLoginException,
+728 IllegalArgumentException {
+729return runAdhocCommand(project, command, nodeFilters, nodeThreadcount, nodeKeepgoing, 5, TimeUnit.SECONDS);
+730 }
+731
+732/**
+733 * Run an ad-hoc command, and wait until its execution is finished (or aborted) to return. We will poll the RunDeck
+734 * server at regular interval (configured by the poolingInterval/poolingUnit couple) to know if the execution is
+735 * finished (or aborted) or is still running. The command will be dispatched to nodes, accordingly to the
+736 * nodeFilters parameter.
+737 *
+738 * @param project name of the project - mandatory
+739 * @param command to be executed - mandatory
+740 * @param nodeFilters for selecting nodes on which the command will be executed. See {@link NodeFiltersBuilder}
+741 * @param nodeThreadcount thread count to use (for parallelizing when running on multiple nodes) - optional
+742 * @param nodeKeepgoing if true, continue executing on other nodes even if some fail - optional
+743 * @param poolingInterval for checking the status of the execution. Must be > 0.
+744 * @param poolingUnit unit (seconds, milli-seconds, ...) of the interval. Default to seconds.
+745 * @return a {@link RundeckExecution} instance for the (finished/aborted) execution - won't be null
+746 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+747 * @throws RundeckApiLoginException if the login failed
+748 * @throws IllegalArgumentException if the project or command is blank (null, empty or whitespace)
+749 * @see #triggerAdhocCommand(String, String, Properties, Integer, Boolean)
+750 */
+751publicRundeckExecution runAdhocCommand(String project, String command, Properties nodeFilters,
+752 Integer nodeThreadcount, Boolean nodeKeepgoing, long poolingInterval, TimeUnit poolingUnit)
+753throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+754if (poolingInterval <= 0) {
+755 poolingInterval = 5;
+756 poolingUnit = TimeUnit.SECONDS;
+757 }
+758if (poolingUnit == null) {
+759 poolingUnit = TimeUnit.SECONDS;
+760 }
+761
+762RundeckExecution execution = triggerAdhocCommand(project, command, nodeFilters, nodeThreadcount, nodeKeepgoing);
+763while (ExecutionStatus.RUNNING.equals(execution.getStatus())) {
+764try {
+765 Thread.sleep(poolingUnit.toMillis(poolingInterval));
+766 } catch (InterruptedException e) {
+767break;
+768 }
+769 execution = getExecution(execution.getId());
+770 }
+771return execution;
+772 }
+773
+774/*
+775 * Executions
+776 */
+777
+778/**
+779 * Get all running executions (for all projects)
+780 *
+781 * @return a {@link List} of {@link RundeckExecution} : might be empty, but won't be null
+782 * @throws RundeckApiException in case of error when calling the API
+783 * @throws RundeckApiLoginException if the login failed
+784 */
+785public List<RundeckExecution> getRunningExecutions() throws RundeckApiException, RundeckApiLoginException {
+786 List<RundeckExecution> executions = new ArrayList<RundeckExecution>();
+787for (RundeckProject project : getProjects()) {
+788 executions.addAll(getRunningExecutions(project.getName()));
+789 }
+790return executions;
+791 }
+792
+793/**
+794 * Get the running executions for the given project
+795 *
+796 * @param project name of the project - mandatory
+797 * @return a {@link List} of {@link RundeckExecution} : might be empty, but won't be null
+798 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+799 * @throws RundeckApiLoginException if the login failed
+800 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
+801 */
+802public List<RundeckExecution> getRunningExecutions(String project) throws RundeckApiException,
+803 RundeckApiLoginException, IllegalArgumentException {
+804 AssertUtil.notBlank(project, "project is mandatory get all running executions !");
+805returnnewApiCall(this).get(newApiPathBuilder("/executions/running").param("project", project),
+806new ListParser<RundeckExecution>(newExecutionParser(),
+807"result/executions/execution"));
+808 }
+809
+810/**
+811 * Get the executions of the given job
+812 *
+813 * @param jobId identifier of the job - mandatory
+814 * @return a {@link List} of {@link RundeckExecution} : might be empty, but won't be null
+815 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+816 * @throws RundeckApiLoginException if the login failed
+817 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+818 */
+819public List<RundeckExecution> getJobExecutions(String jobId) throws RundeckApiException, RundeckApiLoginException,
+820 IllegalArgumentException {
+821return getJobExecutions(jobId, null);
+822 }
+823
+824/**
+825 * Get the executions of the given job
+826 *
+827 * @param jobId identifier of the job - mandatory
+828 * @param status of the executions - optional (null for all)
+829 * @return a {@link List} of {@link RundeckExecution} : might be empty, but won't be null
+830 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+831 * @throws RundeckApiLoginException if the login failed
+832 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+833 */
+834public List<RundeckExecution> getJobExecutions(String jobId, ExecutionStatus status) throws RundeckApiException,
+835 RundeckApiLoginException, IllegalArgumentException {
+836return getJobExecutions(jobId, status, null, null);
+837 }
+838
+839/**
+840 * Get the executions of the given job
+841 *
+842 * @param jobId identifier of the job - mandatory
+843 * @param status of the executions - optional (null for all)
+844 * @param max number of results to return - optional (null for all)
+845 * @param offset the 0-indexed offset for the first result to return - optional
+846 * @return a {@link List} of {@link RundeckExecution} : might be empty, but won't be null
+847 * @throws RundeckApiException in case of error when calling the API (non-existent job with this ID)
+848 * @throws RundeckApiLoginException if the login failed
+849 * @throws IllegalArgumentException if the jobId is blank (null, empty or whitespace)
+850 */
+851public List<RundeckExecution> getJobExecutions(String jobId, ExecutionStatus status, Long max, Long offset)
+852throws RundeckApiException, RundeckApiLoginException, IllegalArgumentException {
+853 AssertUtil.notBlank(jobId, "jobId is mandatory to get the executions of a job !");
+854returnnewApiCall(this).get(newApiPathBuilder("/job/", jobId, "/executions").param("status",
+855 status != null ? StringUtils.lowerCase(status.toString()) : null)
+856 .param("max", max)
+857 .param("offset", offset),
+858new ListParser<RundeckExecution>(newExecutionParser(),
+859"result/executions/execution"));
+860 }
+861
+862/**
+863 * Get a single execution, identified by the given ID
+864 *
+865 * @param executionId identifier of the execution - mandatory
+866 * @return a {@link RundeckExecution} instance - won't be null
+867 * @throws RundeckApiException in case of error when calling the API (non-existent execution with this ID)
+868 * @throws RundeckApiLoginException if the login failed
+869 * @throws IllegalArgumentException if the executionId is null
+870 */
+871publicRundeckExecution getExecution(Long executionId) throws RundeckApiException, RundeckApiLoginException,
+872 IllegalArgumentException {
+873 AssertUtil.notNull(executionId, "executionId is mandatory to get the details of an execution !");
+874returnnewApiCall(this).get(newApiPathBuilder("/execution/", executionId.toString()),
+875newExecutionParser("result/executions/execution"));
+876 }
+877
+878/**
+879 * Abort an execution (identified by the given ID). The execution should be running...
+880 *
+881 * @param executionId identifier of the execution - mandatory
+882 * @return a {@link RundeckAbort} instance - won't be null
+883 * @throws RundeckApiException in case of error when calling the API (non-existent execution with this ID)
+884 * @throws RundeckApiLoginException if the login failed
+885 * @throws IllegalArgumentException if the executionId is null
+886 */
+887publicRundeckAbort abortExecution(Long executionId) throws RundeckApiException, RundeckApiLoginException,
+888 IllegalArgumentException {
+889 AssertUtil.notNull(executionId, "executionId is mandatory to abort an execution !");
+890returnnewApiCall(this).get(newApiPathBuilder("/execution/", executionId.toString(), "/abort"),
+891newAbortParser("result/abort"));
+892 }
+893
+894/*
+895 * Nodes
+896 */
+897
+898/**
+899 * List all nodes (for all projects)
+900 *
+901 * @return a {@link List} of {@link RundeckNode} : might be empty, but won't be null
+902 * @throws RundeckApiException in case of error when calling the API
+903 * @throws RundeckApiLoginException if the login failed
+904 */
+905public List<RundeckNode> getNodes() throws RundeckApiException, RundeckApiLoginException {
+906 List<RundeckNode> nodes = new ArrayList<RundeckNode>();
+907for (RundeckProject project : getProjects()) {
+908 nodes.addAll(getNodes(project.getName()));
+909 }
+910return nodes;
+911 }
+912
+913/**
+914 * List all nodes that belongs to the given project
+915 *
+916 * @param project name of the project - mandatory
+917 * @return a {@link List} of {@link RundeckNode} : might be empty, but won't be null
+918 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+919 * @throws RundeckApiLoginException if the login failed
+920 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
+921 * @see #getNodes(String, Properties)
+922 */
+923public List<RundeckNode> getNodes(String project) throws RundeckApiException, RundeckApiLoginException,
+924 IllegalArgumentException {
+925return getNodes(project, null);
+926 }
+927
+928/**
+929 * List nodes that belongs to the given project
+930 *
+931 * @param project name of the project - mandatory
+932 * @param nodeFilters for filtering the nodes - optional. See {@link NodeFiltersBuilder}
+933 * @return a {@link List} of {@link RundeckNode} : might be empty, but won't be null
+934 * @throws RundeckApiException in case of error when calling the API (non-existent project with this name)
+935 * @throws RundeckApiLoginException if the login failed
+936 * @throws IllegalArgumentException if the project is blank (null, empty or whitespace)
+937 */
+938public List<RundeckNode> getNodes(String project, Properties nodeFilters) throws RundeckApiException,
+939 RundeckApiLoginException, IllegalArgumentException {
+940 AssertUtil.notBlank(project, "project is mandatory to get all nodes !");
+941returnnewApiCall(this).get(newApiPathBuilder("/resources").param("project", project)
+942 .nodeFilters(nodeFilters),
+943new ListParser<RundeckNode>(newNodeParser(), "project/node"));
+944 }
+945
+946/**
+947 * Get the definition of a single node
+948 *
+949 * @param name of the node - mandatory
+950 * @param project name of the project - mandatory
+951 * @return a {@link RundeckNode} instance - won't be null
+952 * @throws RundeckApiException in case of error when calling the API (non-existent name or project with this name)
+953 * @throws RundeckApiLoginException if the login failed
+954 * @throws IllegalArgumentException if the name or project is blank (null, empty or whitespace)
+955 */
+956publicRundeckNode getNode(String name, String project) throws RundeckApiException, RundeckApiLoginException,
+957 IllegalArgumentException {
+958 AssertUtil.notBlank(name, "the name of the node is mandatory to get a node !");
+959 AssertUtil.notBlank(project, "project is mandatory to get a node !");
+960returnnewApiCall(this).get(newApiPathBuilder("/resource/", name).param("project", project),
+961newNodeParser("project/node"));
+962 }
+963
+964/*
+965 * System Info
+966 */
+967
+968/**
+969 * Get system informations about the RunDeck server
+970 *
+971 * @return a {@link RundeckSystemInfo} instance - won't be null
+972 * @throws RundeckApiException in case of error when calling the API
+973 * @throws RundeckApiException if the login failed
+974 */
+975publicRundeckSystemInfo getSystemInfo() throws RundeckApiException, RundeckApiLoginException {
+976returnnewApiCall(this).get(newApiPathBuilder("/system/info"), newSystemInfoParser("result/system"));
+977 }
+978
+979public String getUrl() {
+980return url;
+981 }
+982
+983public String getLogin() {
+984return login;
+985 }
+986
+987public String getPassword() {
+988return password;
+989 }
+990
+991 @Override
+992public String toString() {
+993return"RundeckClient [url=" + url + ", login=" + login + ", password=" + password + "]";
+994 }
+995
+996 @Override
+997publicint hashCode() {
+998finalint prime = 31;
+999int result = 1;
+1000 result = prime * result + ((login == null) ? 0 : login.hashCode());
+1001 result = prime * result + ((password == null) ? 0 : password.hashCode());
+1002 result = prime * result + ((url == null) ? 0 : url.hashCode());
+1003return result;
+1004 }
+1005
+1006 @Override
+1007publicboolean equals(Object obj) {
+1008if (this == obj)
+1009returntrue;
+1010if (obj == null)
+1011return false;
+1012if (getClass() != obj.getClass())
+1013return false;
+1014RundeckClient other = (RundeckClient) obj;
+1015if (login == null) {
+1016if (other.login != null)
+1017return false;
+1018 } elseif (!login.equals(other.login))
+1019return false;
+1020if (password == null) {
+1021if (other.password != null)
+1022return false;
+1023 } elseif (!password.equals(other.password))
+1024return false;
+1025if (url == null) {
+1026if (other.url != null)
+1027return false;
+1028 } elseif (!url.equals(other.url))
+1029return false;
+1030returntrue;
+1031 }
+1032
+1033 }
diff --git a/xref/org/rundeck/api/domain/RundeckExecution.html b/xref/org/rundeck/api/domain/RundeckExecution.html
index 1f56d7b..45f8681 100644
--- a/xref/org/rundeck/api/domain/RundeckExecution.html
+++ b/xref/org/rundeck/api/domain/RundeckExecution.html
@@ -73,207 +73,198 @@
63 }
6465/**
-66 * @return the duration of the execution in seconds (or null if the duration is still running, or has been aborted)
+66 * @return the duration of the execution in seconds (or null if the execution is still running, or has been aborted)67 */68public Long getDurationInSeconds() {
69 Long durationInMillis = getDurationInMillis();
-70if (durationInMillis == null) {
-71returnnull;
-72 }
-73return TimeUnit.MILLISECONDS.toSeconds(durationInMillis);
-74 }
-75
-76/**
-77 * @return the duration of the execution, as a human-readable string : "3 minutes 34 seconds" (or null if the
-78 * duration is still running, or has been aborted)
-79 */
-80public String getDuration() {
-81 Long durationInMillis = getDurationInMillis();
-82if (durationInMillis == null) {
-83returnnull;
-84 }
-85return DurationFormatUtils.formatDurationWords(durationInMillis, true, true);
-86 }
-87
-88/**
-89 * @return the duration of the execution, as a "short" human-readable string : "0:03:34.187" (or null if the
-90 * duration is still running, or has been aborted)
-91 */
-92public String getShortDuration() {
-93 Long durationInMillis = getDurationInMillis();
-94if (durationInMillis == null) {
-95returnnull;
-96 }
-97return DurationFormatUtils.formatDurationHMS(durationInMillis);
-98 }
-99
-100public Long getId() {
-101return id;
-102 }
-103
-104publicvoid setId(Long id) {
-105this.id = id;
-106 }
-107
-108public String getUrl() {
-109return url;
-110 }
-111
-112publicvoid setUrl(String url) {
-113this.url = url;
-114 }
-115
-116/**
-117 * @return the status of the execution - see {@link ExecutionStatus}
-118 */
-119publicExecutionStatus getStatus() {
-120return status;
-121 }
-122
-123publicvoid setStatus(ExecutionStatus status) {
-124this.status = status;
-125 }
-126
-127/**
-128 * @return the {@link RundeckJob} associated with this execution, or null in the case of an ad-hoc execution
-129 * (command or script)
-130 */
-131publicRundeckJob getJob() {
-132return job;
-133 }
-134
-135publicvoid setJob(RundeckJob job) {
-136this.job = job;
-137 }
-138
-139public String getStartedBy() {
-140return startedBy;
-141 }
-142
-143publicvoid setStartedBy(String startedBy) {
-144this.startedBy = startedBy;
-145 }
-146
-147public Date getStartedAt() {
-148return (startedAt != null) ? new Date(startedAt.getTime()) : null;
-149 }
-150
-151publicvoid setStartedAt(Date startedAt) {
-152this.startedAt = ((startedAt != null) ? new Date(startedAt.getTime()) : null);
-153 }
-154
-155public Date getEndedAt() {
-156return (endedAt != null) ? new Date(endedAt.getTime()) : null;
-157 }
-158
-159publicvoid setEndedAt(Date endedAt) {
-160this.endedAt = ((endedAt != null) ? new Date(endedAt.getTime()) : null);
-161 }
-162
-163public String getAbortedBy() {
-164return abortedBy;
-165 }
-166
-167publicvoid setAbortedBy(String abortedBy) {
-168this.abortedBy = abortedBy;
-169 }
-170
-171public String getDescription() {
-172return description;
-173 }
-174
-175publicvoid setDescription(String description) {
-176this.description = description;
-177 }
-178
-179 @Override
-180public String toString() {
-181return"RundeckExecution [id=" + id + ", description=" + description + ", url=" + url + ", status=" + status
-182 + ", startedBy=" + startedBy + ", startedAt=" + startedAt + ", endedAt=" + endedAt
-183 + ", durationInSeconds=" + getDurationInSeconds() + ", abortedBy=" + abortedBy + ", job=" + job + "]";
-184 }
-185
-186 @Override
-187publicint hashCode() {
-188finalint prime = 31;
-189int result = 1;
-190 result = prime * result + ((abortedBy == null) ? 0 : abortedBy.hashCode());
-191 result = prime * result + ((description == null) ? 0 : description.hashCode());
-192 result = prime * result + ((endedAt == null) ? 0 : endedAt.hashCode());
-193 result = prime * result + ((id == null) ? 0 : id.hashCode());
-194 result = prime * result + ((job == null) ? 0 : job.hashCode());
-195 result = prime * result + ((startedAt == null) ? 0 : startedAt.hashCode());
-196 result = prime * result + ((startedBy == null) ? 0 : startedBy.hashCode());
-197 result = prime * result + ((status == null) ? 0 : status.hashCode());
-198 result = prime * result + ((url == null) ? 0 : url.hashCode());
-199return result;
-200 }
-201
-202 @Override
-203publicboolean equals(Object obj) {
-204if (this == obj)
-205returntrue;
-206if (obj == null)
-207return false;
-208if (getClass() != obj.getClass())
-209return false;
-210RundeckExecution other = (RundeckExecution) obj;
-211if (abortedBy == null) {
-212if (other.abortedBy != null)
-213return false;
-214 } elseif (!abortedBy.equals(other.abortedBy))
-215return false;
-216if (description == null) {
-217if (other.description != null)
-218return false;
-219 } elseif (!description.equals(other.description))
-220return false;
-221if (endedAt == null) {
-222if (other.endedAt != null)
-223return false;
-224 } elseif (!endedAt.equals(other.endedAt))
-225return false;
-226if (id == null) {
-227if (other.id != null)
-228return false;
-229 } elseif (!id.equals(other.id))
-230return false;
-231if (job == null) {
-232if (other.job != null)
-233return false;
-234 } elseif (!job.equals(other.job))
-235return false;
-236if (startedAt == null) {
-237if (other.startedAt != null)
-238return false;
-239 } elseif (!startedAt.equals(other.startedAt))
-240return false;
-241if (startedBy == null) {
-242if (other.startedBy != null)
-243return false;
-244 } elseif (!startedBy.equals(other.startedBy))
-245return false;
-246if (status == null) {
-247if (other.status != null)
-248return false;
-249 } elseif (!status.equals(other.status))
-250return false;
-251if (url == null) {
-252if (other.url != null)
-253return false;
-254 } elseif (!url.equals(other.url))
-255return false;
-256returntrue;
-257 }
-258
-259/**
-260 * The status of an execution
-261 */
-262publicstatic enum ExecutionStatus {
-263 RUNNING, SUCCEEDED, FAILED, ABORTED;
-264 }
-265
-266 }
+70return durationInMillis != null ? TimeUnit.MILLISECONDS.toSeconds(durationInMillis) : null;
+71 }
+72
+73/**
+74 * @return the duration of the execution, as a human-readable string : "3 minutes 34 seconds" (or null if the
+75 * execution is still running, or has been aborted)
+76 */
+77public String getDuration() {
+78 Long durationInMillis = getDurationInMillis();
+79return durationInMillis != null ? DurationFormatUtils.formatDurationWords(durationInMillis, true, true) : null;
+80 }
+81
+82/**
+83 * @return the duration of the execution, as a "short" human-readable string : "0:03:34.187" (or null if the
+84 * execution is still running, or has been aborted)
+85 */
+86public String getShortDuration() {
+87 Long durationInMillis = getDurationInMillis();
+88return durationInMillis != null ? DurationFormatUtils.formatDurationHMS(durationInMillis) : null;
+89 }
+90
+91public Long getId() {
+92return id;
+93 }
+94
+95publicvoid setId(Long id) {
+96this.id = id;
+97 }
+98
+99public String getUrl() {
+100return url;
+101 }
+102
+103publicvoid setUrl(String url) {
+104this.url = url;
+105 }
+106
+107/**
+108 * @return the status of the execution - see {@link ExecutionStatus}
+109 */
+110publicExecutionStatus getStatus() {
+111return status;
+112 }
+113
+114publicvoid setStatus(ExecutionStatus status) {
+115this.status = status;
+116 }
+117
+118/**
+119 * @return the {@link RundeckJob} associated with this execution, or null in the case of an ad-hoc execution
+120 * (command or script)
+121 */
+122publicRundeckJob getJob() {
+123return job;
+124 }
+125
+126publicvoid setJob(RundeckJob job) {
+127this.job = job;
+128 }
+129
+130public String getStartedBy() {
+131return startedBy;
+132 }
+133
+134publicvoid setStartedBy(String startedBy) {
+135this.startedBy = startedBy;
+136 }
+137
+138public Date getStartedAt() {
+139return (startedAt != null) ? new Date(startedAt.getTime()) : null;
+140 }
+141
+142publicvoid setStartedAt(Date startedAt) {
+143this.startedAt = ((startedAt != null) ? new Date(startedAt.getTime()) : null);
+144 }
+145
+146public Date getEndedAt() {
+147return (endedAt != null) ? new Date(endedAt.getTime()) : null;
+148 }
+149
+150publicvoid setEndedAt(Date endedAt) {
+151this.endedAt = ((endedAt != null) ? new Date(endedAt.getTime()) : null);
+152 }
+153
+154public String getAbortedBy() {
+155return abortedBy;
+156 }
+157
+158publicvoid setAbortedBy(String abortedBy) {
+159this.abortedBy = abortedBy;
+160 }
+161
+162public String getDescription() {
+163return description;
+164 }
+165
+166publicvoid setDescription(String description) {
+167this.description = description;
+168 }
+169
+170 @Override
+171public String toString() {
+172return"RundeckExecution [id=" + id + ", description=" + description + ", url=" + url + ", status=" + status
+173 + ", startedBy=" + startedBy + ", startedAt=" + startedAt + ", endedAt=" + endedAt
+174 + ", durationInSeconds=" + getDurationInSeconds() + ", abortedBy=" + abortedBy + ", job=" + job + "]";
+175 }
+176
+177 @Override
+178publicint hashCode() {
+179finalint prime = 31;
+180int result = 1;
+181 result = prime * result + ((abortedBy == null) ? 0 : abortedBy.hashCode());
+182 result = prime * result + ((description == null) ? 0 : description.hashCode());
+183 result = prime * result + ((endedAt == null) ? 0 : endedAt.hashCode());
+184 result = prime * result + ((id == null) ? 0 : id.hashCode());
+185 result = prime * result + ((job == null) ? 0 : job.hashCode());
+186 result = prime * result + ((startedAt == null) ? 0 : startedAt.hashCode());
+187 result = prime * result + ((startedBy == null) ? 0 : startedBy.hashCode());
+188 result = prime * result + ((status == null) ? 0 : status.hashCode());
+189 result = prime * result + ((url == null) ? 0 : url.hashCode());
+190return result;
+191 }
+192
+193 @Override
+194publicboolean equals(Object obj) {
+195if (this == obj)
+196returntrue;
+197if (obj == null)
+198return false;
+199if (getClass() != obj.getClass())
+200return false;
+201RundeckExecution other = (RundeckExecution) obj;
+202if (abortedBy == null) {
+203if (other.abortedBy != null)
+204return false;
+205 } elseif (!abortedBy.equals(other.abortedBy))
+206return false;
+207if (description == null) {
+208if (other.description != null)
+209return false;
+210 } elseif (!description.equals(other.description))
+211return false;
+212if (endedAt == null) {
+213if (other.endedAt != null)
+214return false;
+215 } elseif (!endedAt.equals(other.endedAt))
+216return false;
+217if (id == null) {
+218if (other.id != null)
+219return false;
+220 } elseif (!id.equals(other.id))
+221return false;
+222if (job == null) {
+223if (other.job != null)
+224return false;
+225 } elseif (!job.equals(other.job))
+226return false;
+227if (startedAt == null) {
+228if (other.startedAt != null)
+229return false;
+230 } elseif (!startedAt.equals(other.startedAt))
+231return false;
+232if (startedBy == null) {
+233if (other.startedBy != null)
+234return false;
+235 } elseif (!startedBy.equals(other.startedBy))
+236return false;
+237if (status == null) {
+238if (other.status != null)
+239return false;
+240 } elseif (!status.equals(other.status))
+241return false;
+242if (url == null) {
+243if (other.url != null)
+244return false;
+245 } elseif (!url.equals(other.url))
+246return false;
+247returntrue;
+248 }
+249
+250/**
+251 * The status of an execution
+252 */
+253publicstatic enum ExecutionStatus {
+254 RUNNING, SUCCEEDED, FAILED, ABORTED;
+255 }
+256
+257 }
diff --git a/xref/org/rundeck/api/domain/RundeckProject.html b/xref/org/rundeck/api/domain/RundeckProject.html
index 54dd345..712179e 100644
--- a/xref/org/rundeck/api/domain/RundeckProject.html
+++ b/xref/org/rundeck/api/domain/RundeckProject.html
@@ -40,59 +40,76 @@
3031private String description;
32
-33public String getName() {
-34return name;
-35 }
-36
-37publicvoid setName(String name) {
-38this.name = name;
-39 }
-40
-41public String getDescription() {
-42return description;
-43 }
-44
-45publicvoid setDescription(String description) {
-46this.description = description;
-47 }
-48
-49 @Override
-50public String toString() {
-51return"RundeckProject [name=" + name + ", description=" + description + "]";
-52 }
-53
-54 @Override
-55publicint hashCode() {
-56finalint prime = 31;
-57int result = 1;
-58 result = prime * result + ((description == null) ? 0 : description.hashCode());
-59 result = prime * result + ((name == null) ? 0 : name.hashCode());
-60return result;
-61 }
-62
-63 @Override
-64publicboolean equals(Object obj) {
-65if (this == obj)
-66returntrue;
-67if (obj == null)
-68return false;
-69if (getClass() != obj.getClass())
-70return false;
-71RundeckProject other = (RundeckProject) obj;
-72if (description == null) {
-73if (other.description != null)
-74return false;
-75 } elseif (!description.equals(other.description))
-76return false;
-77if (name == null) {
-78if (other.name != null)
-79return false;
-80 } elseif (!name.equals(other.name))
-81return false;
-82returntrue;
-83 }
-84
-85 }
+33private String resourceModelProviderUrl;
+34
+35public String getName() {
+36return name;
+37 }
+38
+39publicvoid setName(String name) {
+40this.name = name;
+41 }
+42
+43public String getDescription() {
+44return description;
+45 }
+46
+47publicvoid setDescription(String description) {
+48this.description = description;
+49 }
+50
+51public String getResourceModelProviderUrl() {
+52return resourceModelProviderUrl;
+53 }
+54
+55publicvoid setResourceModelProviderUrl(String resourceModelProviderUrl) {
+56this.resourceModelProviderUrl = resourceModelProviderUrl;
+57 }
+58
+59 @Override
+60public String toString() {
+61return"RundeckProject [name=" + name + ", description=" + description + ", resourceModelProviderUrl="
+62 + resourceModelProviderUrl + "]";
+63 }
+64
+65 @Override
+66publicint hashCode() {
+67finalint prime = 31;
+68int result = 1;
+69 result = prime * result + ((description == null) ? 0 : description.hashCode());
+70 result = prime * result + ((name == null) ? 0 : name.hashCode());
+71 result = prime * result + ((resourceModelProviderUrl == null) ? 0 : resourceModelProviderUrl.hashCode());
+72return result;
+73 }
+74
+75 @Override
+76publicboolean equals(Object obj) {
+77if (this == obj)
+78returntrue;
+79if (obj == null)
+80return false;
+81if (getClass() != obj.getClass())
+82return false;
+83RundeckProject other = (RundeckProject) obj;
+84if (description == null) {
+85if (other.description != null)
+86return false;
+87 } elseif (!description.equals(other.description))
+88return false;
+89if (name == null) {
+90if (other.name != null)
+91return false;
+92 } elseif (!name.equals(other.name))
+93return false;
+94if (resourceModelProviderUrl == null) {
+95if (other.resourceModelProviderUrl != null)
+96return false;
+97 } elseif (!resourceModelProviderUrl.equals(other.resourceModelProviderUrl))
+98return false;
+99returntrue;
+100 }
+101
+102 }
diff --git a/xref/org/rundeck/api/domain/RundeckSystemInfo.html b/xref/org/rundeck/api/domain/RundeckSystemInfo.html
new file mode 100644
index 0000000..6de7565
--- /dev/null
+++ b/xref/org/rundeck/api/domain/RundeckSystemInfo.html
@@ -0,0 +1,386 @@
+
+
+
+
+RundeckSystemInfo xref
+
+
+
+
+
+1/*
+2 * Copyright 2011 Vincent Behar
+3 *
+4 * Licensed under the Apache License, Version 2.0 (the "License");
+5 * you may not use this file except in compliance with the License.
+6 * You may obtain a copy of the License at
+7 *
+8 * http://www.apache.org/licenses/LICENSE-2.0
+9 *
+10 * Unless required by applicable law or agreed to in writing, software
+11 * distributed under the License is distributed on an "AS IS" BASIS,
+12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+13 * See the License for the specific language governing permissions and
+14 * limitations under the License.
+15 */
+16package org.rundeck.api.parser;
+17
+18import java.util.Date;
+19import org.apache.commons.lang.StringUtils;
+20import org.dom4j.Node;
+21import org.rundeck.api.domain.RundeckSystemInfo;
+22
+23/**
+24 * Parser for a single {@link RundeckSystemInfo}
+25 *
+26 * @author Vincent Behar
+27 */
+28publicclassSystemInfoParserimplements XmlNodeParser<RundeckSystemInfo> {
+29
+30private String xpath;
+31
+32publicSystemInfoParser() {
+33super();
+34 }
+35
+36/**
+37 * @param xpath of the systemInfo element if it is not the root node
+38 */
+39publicSystemInfoParser(String xpath) {
+40super();
+41this.xpath = xpath;
+42 }
+43
+44 @Override
+45publicRundeckSystemInfo parseXmlNode(Node node) {
+46 Node infoNode = xpath != null ? node.selectSingleNode(xpath) : node;
+47
+48RundeckSystemInfo info = newRundeckSystemInfo();
+49
+50 String timestamp = StringUtils.trimToNull(infoNode.valueOf("timestamp/@epoch"));
+51if (timestamp != null) {
+52 info.setDate(new Date(Long.valueOf(timestamp)));
+53 }
+54 info.setVersion(StringUtils.trimToNull(infoNode.valueOf("rundeck/version")));
+55 info.setBuild(StringUtils.trimToNull(infoNode.valueOf("rundeck/build")));
+56 info.setNode(StringUtils.trimToNull(infoNode.valueOf("rundeck/node")));
+57 info.setBaseDir(StringUtils.trimToNull(infoNode.valueOf("rundeck/base")));
+58 info.setOsArch(StringUtils.trimToNull(infoNode.valueOf("os/arch")));
+59 info.setOsName(StringUtils.trimToNull(infoNode.valueOf("os/name")));
+60 info.setOsVersion(StringUtils.trimToNull(infoNode.valueOf("os/version")));
+61 info.setJvmName(StringUtils.trimToNull(infoNode.valueOf("jvm/name")));
+62 info.setJvmVendor(StringUtils.trimToNull(infoNode.valueOf("jvm/vendor")));
+63 info.setJvmVersion(StringUtils.trimToNull(infoNode.valueOf("jvm/version")));
+64 String startDate = StringUtils.trimToNull(infoNode.valueOf("stats/uptime/since/@epoch"));
+65if (startDate != null) {
+66 info.setStartDate(new Date(Long.valueOf(startDate)));
+67 }
+68 info.setUptimeInMillis(Long.valueOf(infoNode.valueOf("stats/uptime/@duration")));
+69 info.setCpuLoadAverage(StringUtils.trimToNull(infoNode.valueOf("stats/cpu/loadAverage")));
+70if (info.getCpuLoadAverage() != null) {
+71 info.setCpuLoadAverage(info.getCpuLoadAverage() + " %");
+72 }
+73 info.setMaxMemoryInBytes(Long.valueOf(infoNode.valueOf("stats/memory/max")));
+74 info.setFreeMemoryInBytes(Long.valueOf(infoNode.valueOf("stats/memory/free")));
+75 info.setTotalMemoryInBytes(Long.valueOf(infoNode.valueOf("stats/memory/total")));
+76 info.setRunningJobs(Integer.valueOf(infoNode.valueOf("stats/scheduler/running")));
+77 info.setActiveThreads(Integer.valueOf(infoNode.valueOf("stats/threads/active")));
+78
+79return info;
+80 }
+81 }
+
org.rundeck.api.domain.RundeckSystemInfo +
-