/*
* Copyright 2010-2012, CloudBees Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.cloudbees.api;
import com.cloudbees.api.config.ConfigParameters;
import com.cloudbees.api.config.ParameterSettings;
import com.cloudbees.api.config.ResourceSettings;
import com.cloudbees.api.oauth.OauthClient;
import com.cloudbees.upload.ArchiveUtils;
import com.cloudbees.upload.JarUtils;
import com.cloudbees.utils.AppConfigHelper;
import com.cloudbees.utils.ZipHelper;
import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.json.JettisonMappedXmlDriver;
import com.thoughtworks.xstream.mapper.MapperWrapper;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.HttpMethodBase;
import org.apache.commons.httpclient.methods.*;
import org.apache.commons.io.IOUtils;
import org.codehaus.jackson.map.DeserializationConfig.Feature;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.map.introspect.VisibilityChecker.Std;
import org.codehaus.jettison.json.JSONObject;
import java.io.*;
import java.math.BigInteger;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.zip.ZipEntry;
import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.ANY;
import static org.codehaus.jackson.annotate.JsonAutoDetect.Visibility.NONE;
/**
* Main entry point to the CloudBees API.
*
* @author Fabian Donze
* @author Kohsuke Kawaguchi
*/
public class BeesClient extends BeesClientBase {
/**
* The encoded value we send in as the "Authorization" header.
*/
private String encodedAccountAuthorization;
/**
* The API endpoint, such as "https://api.cloudbees.com/"
*/
private URL base;
static Logger logger = Logger.getLogger(BeesClient.class.getSimpleName());
/**
* Used for mapping JSON to Java objects.
*/
/*package*/ static final ObjectMapper MAPPER = new ObjectMapper();
static {
MAPPER.setVisibilityChecker(new Std(NONE, NONE, NONE, NONE, ANY));
MAPPER.getDeserializationConfig().set(Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);
}
public BeesClient(BeesClientConfiguration beesClientConfiguration) {
super(beesClientConfiguration);
init();
}
/**
* Creates a client that talks to the CloudBees production API endpoint
*
* To obtain your API key an the secret, visit https://grandcentral.cloudbees.com/user/keys
*
* If you have reigstered an OAuth application and talking to CloudBees as that OAuth
* application (for example to validate OAuth tokens you received from your users via browser),
* then you can specify that OAuth client ID and the secret.
*/
public BeesClient(String apikey, String secret) {
this("https://api.cloudbees.com/api ", apikey, secret);
}
public BeesClient(String server, String apikey, String secret) {
this(server, apikey, secret,null,null);
}
public BeesClient(String server, String apikey, String secret,
String format, String version) {
// TODO: this encodePassword is considered harmful as it creates assymetry between two constructors
super(server, apikey, encodePassword(secret, version), format,
version);
init();
}
/**
* Common initialization code in this class.
*/
private void init() {
BeesClientConfiguration conf = getBeesClientConfiguration();
try {
base = new URL(conf.getServerApiUrl());
} catch (MalformedURLException e) {
throw new IllegalArgumentException("Invalid API URL:" + conf.getServerApiUrl(), e);
}
encodedAccountAuthorization = conf.getAuthorization();
}
/**
* Obtains another interface of the API client that defines OAuth APIs.
*
* In API world, api-staging is not in a separate environment,
* it is part of the main production environment but offers the latest
* and greatest interface to the production data model.
*
* URL Resolution:
* api.cloudbees.com => grandcentral.cloudbees.com
* api-staging.cloudbees.com => grandcentral.cloudbees.com
* api.beescloud.com => grandcentral.beescloud.com
* api-staging.beescloud.com => grandcentral.beescloud.com
*
* <p>
* This method does not involve any remote call.
*
* @return never null
*/
public OauthClient getOauthClient() {
String gc = base.toExternalForm();
gc = gc.replace("//api.", "//grandcentral.");
gc = gc.replace("//api-staging.", "//grandcentral.");
if (gc.equals(base.toExternalForm())) {
throw new RuntimeException("Unable to determine GrandCentral URL from " + base.toExternalForm());
}
// cut off the path portion
while (true) {
int scheme = gc.indexOf("://");
int path = gc.lastIndexOf('/');
if (path>scheme+3) {
gc = gc.substring(0,path);
} else
break;
}
return new OauthClientImpl(this, gc);
}
/**
* Create OAuth client using the given GC URL. It's useful for client apps who want to test their functionality with
* GC instances running locally or elsewhere for individual testing.
*
* It also decouples RUN api instance from GC instance, useful in certain test scenarios
*
* @param gcUrl If null defaults to https://grandcentral.cloudbees.com
*
*/
public OauthClient getOauthClient(String gcUrl) {
if(gcUrl == null){
gcUrl = "https://grandcentral.cloudbees.com";
}
return new OauthClientImpl(this, gcUrl);
}
/**
* Creates an user, including a partial user creation.
*
* @see <a href="https://sites.google.com/a/cloudbees
* .com/account-provisioning-api/home/user-api#TOC-Create-a-User">API spec</a>
*/
public CBUser createUser(CBUser user) throws IOException {
return jsonPOJORequest("v2/users", user, CBUser.class, "POST");
}
/**
* Updates the user record.
*
* @param id The ID of the user to update. Corresponds to {@link CBUser#id}.
* @param user You should only set fields that you want to update, and leave everything else to null, to indicate
* those values should remain untouched.
*/
public CBUser updateUser(String id, CBUser user) throws IOException {
return jsonPOJORequest("v2/users/" + id, user, CBUser.class, "PATCH");
}
/**
* Deletes an user.
*/
public void deleteUser(String id) throws IOException {
jsonPOJORequest("v2/users/" + id, null, null, "DELETE");
}
public CBUser addUserToAccount(CBAccount account, CBUser user) throws IOException {
return jsonPOJORequest("v2/users/" + user.id + "/accounts/" + account.name + "/users", user, CBUser.class,
"POST");
}
/**
* The actual engine behind the REST API call.
* <p/>
* It sends a request in JSON and expects a JSON response back.
* Note that for historical reasons, there's the other half of the API that uses query parameters + digital signing.
*
* @param apiTail The end point to hit. Appended to {@link #base}. Shouldn't start with '/'
* @param request JSON-bound POJO object that represents the request payload, or null if none.
* @param type JSON-bound POJO class to unmarshal the response into.
* @param method HTTP method name like GET or POST.
* @throws IOException If the communication fails.
*/
protected <T> T jsonPOJORequest(String apiTail, Object request, Class<T> type, String method) throws IOException {
String content = null;
if (request != null) {
content = MAPPER.writeValueAsString(request);
}
HttpReply resp = jsonRequest(apiTail, method, null, content);
return resp.bind(type,this);
}
/**
* Sends a request in JSON and expects a JSON response back.
*
* @param urlTail The end point to hit. Appended to {@link #base}. Shouldn't start with '/'
* @param method HTTP method name like GET or POST.
* @param headers
*@param jsonContent The json request payload, or null if none. @throws IOException If the communication fails.
*/
public HttpReply jsonRequest(String urlTail, String method, Map<String, String> headers, String jsonContent) throws IOException {
HttpMethodBase httpMethod;
String urlString = absolutize(urlTail);
trace("API call: " + urlString);
if (method.equalsIgnoreCase("GET")) {
httpMethod = new GetMethod(urlString);
} else if ((method.equalsIgnoreCase("POST"))) {
httpMethod = new PostMethod(urlString);
} else if ((method.equalsIgnoreCase("PUT"))) {
httpMethod = new PutMethod(urlString);
} else if ((method.equalsIgnoreCase("DELETE"))) {
httpMethod = new DeleteMethod(urlString);
} else if ((method.equalsIgnoreCase("PATCH"))) {
httpMethod = new PatchMethod(urlString);
} else if ((method.equalsIgnoreCase("HEAD"))) {
httpMethod = new HeadMethod(urlString);
} else if ((method.equalsIgnoreCase("TRACE"))) {
httpMethod = new TraceMethod(urlString);
} else if ((method.equalsIgnoreCase("OPTIONS"))) {
httpMethod = new OptionsMethod(urlString);
} else
throw new IOException("Method not supported: " + method);
httpMethod.setRequestHeader("Accept", "application/json");
if (jsonContent != null && httpMethod instanceof EntityEnclosingMethod) {
StringRequestEntity requestEntity = new StringRequestEntity(jsonContent, "application/json", "UTF-8");
((EntityEnclosingMethod)httpMethod).setRequestEntity(requestEntity);
trace("Payload: " + jsonContent);
}
return executeRequest(httpMethod,headers);
}
/**
* Sends a request in JSON and expects a JSON response back.
*
* @param urlTail The end point to hit. Appended to {@link #base}. Shouldn't start with '/'
* @param headers HTTP headers
* @param params
* Form parameters
*/
/*package*/ HttpReply formUrlEncoded(String urlTail, Map<String, String> headers, Map<String,List<String>> params) throws IOException {
String urlString = absolutize(urlTail);
trace("API call: " + urlString);
PostMethod httpMethod = new PostMethod(urlString);
httpMethod.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
for (Entry<String, List<String>> e : params.entrySet()) {
for (String v : e.getValue()) {
httpMethod.addParameter(e.getKey(),v);
}
}
return executeRequest(httpMethod,headers);
}
/**
* Computes the absolute URL to send the request to from the tail portion.
*/
private String absolutize(String urlTail) throws IOException {
URL url = new URL(base, urlTail);
String urlString;
try {
urlString = url.toURI().toString();
} catch (URISyntaxException e) {
throw new IllegalArgumentException("Invalid API URL:" + url.toString(), e);
}
return urlString;
}
/**
* Executes an HTTP method.
*/
private HttpReply executeRequest(HttpMethod httpMethod, Map<String, String> headers) throws IOException {
BeesClientConfiguration conf = getBeesClientConfiguration();
HttpClient httpClient = HttpClientHelper.createClient(conf);
if (encodedAccountAuthorization != null)
httpMethod.setRequestHeader("Authorization", encodedAccountAuthorization);
if (headers != null) {
for (Map.Entry<String, String> entry: headers.entrySet()) {
httpMethod.setRequestHeader(entry.getKey(), entry.getValue());
}
}
int status = 500;
String rsp = "Error";
try {
status = httpClient.executeMethod(httpMethod);
rsp = IOUtils.toString(httpMethod.getResponseBodyAsStream());
} catch (IOException e) {
throw (IOException)new IOException("Failed to " + httpMethod.getName() + " : " + httpMethod.getURI() + " : code=" + status + " response=" + e.getMessage()).initCause(e);
} finally {
httpMethod.releaseConnection();
}
trace(status + ": " + rsp);
return new HttpReply(httpMethod, status, rsp);
}
public CBAccount getAccount(String name) throws IOException {
return jsonPOJORequest("v2/accounts/" + name, null, CBAccount.class, "GET");
}
/**
* Looks up the user by ID.
*/
public CBUser getUser(String id) throws IOException {
return jsonPOJORequest("v2/users/" + id, null, CBUser.class, "GET");
}
/**
* Retrieves the information of the current user.
*
* The "current user" refers to the user who generated the token used to authenticate the method call.
*/
public CBUser getSelfUser() throws IOException {
return getUser("self");
}
/**
* Looks up the user by the public key fingerprint
*
* @param sshPublicKeyFingerprint Fingerprint formatted as "12:34:56:..:aa:bb:cc" (case insensitive)
*/
public CBUser getUserByFingerprint(String sshPublicKeyFingerprint) throws IOException {
return jsonPOJORequest("v2/users/fingerprint/" + sshPublicKeyFingerprint, null, CBUser.class, "GET");
}
public SayHelloResponse sayHello(String message) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("message", message);
String url = getRequestURL("say.hello", params);
String response = executeRequest(url);
return (SayHelloResponse) readResponse(response);
}
public ApplicationGetSourceUrlResponse applicationGetSourceUrl(
String appId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
String url = getRequestURL("application.getSourceUrl", params);
String response = executeRequest(url);
return (ApplicationGetSourceUrlResponse) readResponse(response);
}
public ApplicationDeleteResponse applicationDelete(String appId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
String url = getRequestURL("application.delete", params);
String response = executeRequest(url);
return (ApplicationDeleteResponse) readResponse(response);
}
public ApplicationRestartResponse applicationRestart(String appId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
String url = getRequestURL("application.restart", params);
String response = executeRequest(url);
return (ApplicationRestartResponse) readResponse(response);
}
public ApplicationStatusResponse applicationStart(String appId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
String url = getRequestURL("application.start", params);
String response = executeRequest(url);
return (ApplicationStatusResponse) readResponse(response);
}
public ApplicationStatusResponse applicationStop(String appId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
String url = getRequestURL("application.stop", params);
String response = executeRequest(url);
return (ApplicationStatusResponse) readResponse(response);
}
public ApplicationStatusResponse applicationHibernate(String appId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
String url = getRequestURL("application.hibernate", params);
String response = executeRequest(url);
ApplicationStatusResponse apiResponse =
(ApplicationStatusResponse)readResponse(response);
return apiResponse;
}
/**
* Returns all the applications in all the account sthat you belong to.
* <p/>
* Short-hand for {@code applicationList(null)}.
*/
public ApplicationListResponse applicationList() throws Exception {
return applicationList(null);
}
/**
* Returns all the applications in the specified account.
*
* @param account if null, returns all the applications from all the accounts that you belong to.
* @since 1.1.3
*/
public ApplicationListResponse applicationList(String account) throws Exception {
Map<String, String> params = new HashMap<String, String>();
if (account != null) {
params.put("account", account);
}
String url = getRequestURL("application.list", params);
String response = executeRequest(url);
return (ApplicationListResponse) readResponse(response);
}
public ApplicationInfo applicationInfo(String appId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
String url = getRequestURL("application.info", params);
String response = executeRequest(url);
ApplicationInfoResponse apiResponse =
(ApplicationInfoResponse) readResponse(response);
return apiResponse.getApplicationInfo();
}
public ApplicationSetMetaResponse applicationSetMeta(String appId,
Map<String, String> metaAttrs) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.putAll(metaAttrs);
params.put("app_id", appId);
String url = getRequestURL("application.setMeta", params);
String response = executeRequest(url);
return (ApplicationSetMetaResponse) readResponse(response);
}
/**
* @deprecated
*/
public ApplicationJarHashesResponse applicationJarCrcs(String appId, Map<String, String> hashes) throws Exception {
return applicationJarHashes(appId, hashes);
}
public ApplicationJarHashesResponse applicationJarHashes(String appId, Map<String, String> hashes)
throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
params.put("hashes", createParameter(hashes));
String url = getApiUrl("application.jarHashes").toString();
params.put("action", "application.jarHashes");
// use the upload method (POST) to handle the potentially large "hashes" parameter payload
String response = executeUpload(url, params, new HashMap<String, File>(), null);
return (ApplicationJarHashesResponse) readResponse(response);
}
/**
* @deprecated use {@link #applicationDeployEar(String, String, String, java.io.File, java.io.File, UploadProgress)}
*/
@Deprecated
public ApplicationDeployArchiveResponse applicationDeployEar(
String appId, String environment, String description, String earFile,
String srcFile, UploadProgress progress) throws Exception {
return applicationDeployEar(appId, environment, description,
asFile(earFile), asFile(srcFile), progress);
}
/**
* @since 1.1.4
*/
public ApplicationDeployArchiveResponse applicationDeployEar(
String appId, String environment, String description, File earFile,
File srcFile, UploadProgress progress) throws Exception {
String archiveType = "ear";
return applicationDeployArchive(appId, environment, description,
earFile, srcFile, archiveType, false, progress);
}
/**
* @deprecated use {@link #applicationDeployWar(String, String, String, File, File, UploadProgress)}
*/
@Deprecated
public ApplicationDeployArchiveResponse applicationDeployWar(
String appId, String environment, String description, String warFile,
String srcFile, UploadProgress progress) throws Exception {
return applicationDeployWar(appId, environment, description, asFile(warFile),
asFile(srcFile), progress);
}
/**
* @since 1.1.4
*/
public ApplicationDeployArchiveResponse applicationDeployWar(
String appId, String environment, String description, File warFile,
File srcFile, UploadProgress progress) throws Exception {
return applicationDeployWar(appId, environment, description, warFile,
srcFile, true, progress);
}
/**
* @deprecated use {@link #applicationDeployWar(String, String, String, File, File, boolean, UploadProgress)}
*/
@Deprecated
public ApplicationDeployArchiveResponse applicationDeployWar(
String appId, String environment, String description, String warFile,
String srcFile, boolean deltaDeploy, UploadProgress progress) throws Exception {
return applicationDeployWar(appId, environment, description,
asFile(warFile), asFile(srcFile), deltaDeploy, progress);
}
/**
* @since 1.1.4
*/
public ApplicationDeployArchiveResponse applicationDeployWar(
String appId, String environment, String description, File warFile,
File srcFile, boolean deltaDeploy, UploadProgress progress) throws Exception {
String archiveType = "war";
return applicationDeployArchive(appId, environment, description,
warFile, srcFile, archiveType, deltaDeploy, progress);
}
/**
* @deprecated use {@link #applicationDeployArchive(String, String, String, File, File, String, UploadProgress)}
*/
@Deprecated
public ApplicationDeployArchiveResponse applicationDeployArchive(
String appId, String environment, String description, String earFile,
String srcFile, String archiveType, UploadProgress progress) throws Exception {
return applicationDeployArchive(appId, environment, description, asFile(earFile), asFile(srcFile), archiveType,
progress);
}
/**
* @since 1.1.4
*/
public ApplicationDeployArchiveResponse applicationDeployArchive(
String appId, String environment, String description, File earFile,
File srcFile, String archiveType, UploadProgress progress) throws Exception {
return applicationDeployArchive(appId, environment, description, earFile, srcFile, archiveType, false,
progress);
}
/**
* @deprecated use {@link #applicationDeployArchive(String, String, String, File, File, String, boolean,
* UploadProgress)}
*/
@Deprecated
public ApplicationDeployArchiveResponse applicationDeployArchive(
String appId, String environment, String description, String earFile,
String srcFile, String archiveType, boolean deltaDeploy, UploadProgress progress) throws Exception {
return applicationDeployArchive(appId, environment, description, asFile(earFile), asFile(srcFile), archiveType,
deltaDeploy, progress);
}
/**
* @since 1.1.4
*/
public ApplicationDeployArchiveResponse applicationDeployArchive(
String appId, String environment, String description, File earFile,
File srcFile, String archiveType, boolean deltaDeploy, UploadProgress progress) throws Exception {
return applicationDeployArchive(appId, environment, description, earFile, srcFile, archiveType, deltaDeploy,
null, progress);
}
/**
* @deprecated use {@link #applicationDeployArchive(String, String, String, File, File, String, boolean, Map,
* UploadProgress)}
*/
@Deprecated
public ApplicationDeployArchiveResponse applicationDeployArchive(
String appId, String environment, String description, String earFile,
String srcFile, String archiveType, boolean deltaDeploy, Map<String, String> parameters,
UploadProgress progress) throws Exception {
return applicationDeployArchive(appId, environment, description, asFile(earFile), asFile(srcFile), archiveType,
deltaDeploy, parameters, progress);
}
/**
* @since 1.1.4
*/
public ApplicationDeployArchiveResponse applicationDeployArchive(
String appId, String environment, String description, File earFile,
File srcFile, String archiveType, boolean deltaDeploy, Map<String, String> parameters,
UploadProgress progress) throws Exception {
return applicationDeployArchive(new ApplicationDeployArgs.Builder(appId)
.environment(environment).description(description)
.deployPackage(earFile, archiveType).srcFile(srcFile)
.incrementalDeployment(deltaDeploy).withParams(parameters)
.withProgressFeedback(progress).build());
}
public ApplicationDeployArchiveResponse applicationDeployArchive(ApplicationDeployArgs args) throws Exception {
Map<String, String> params = new HashMap<String, String>();
Map<String, File> fileParams = new HashMap<String, File>();
params.put("app_id", args.appId);
File archiveFile = args.archiveFile;
// Currently do not support ear file for delta upload
boolean deployDelta = false;
boolean deployJarDelta = false;
// Create delta deploy File
if (args.deltaDeploy && !args.archiveType.equals("ear")) {
trace("Get existing checksums");
ApplicationCheckSumsResponse applicationCheckSumsResponse = applicationCheckSums(args.appId, false);
if (logger.isLoggable(Level.FINER)) {
for (Map.Entry<String, Long> entry : applicationCheckSumsResponse.getCheckSums().entrySet()) {
logger.finer("Entry: " + entry.getKey() + " CRC: " + entry.getValue());
}
}
if (applicationCheckSumsResponse.getCheckSums().size() == 0) {
trace("No existing checksums, upload full archive");
} else {
trace("Creating Delta archive for: " + archiveFile);
archiveFile = ArchiveUtils.createDeltaWarFile(applicationCheckSumsResponse.getCheckSums(), archiveFile,
archiveFile.getParent());
deployDelta = true;
if (applicationCheckSumsResponse.getSnapshotID() != null)
params.put("delta_snapshot_id", applicationCheckSumsResponse.getSnapshotID());
}
}
if (args.deltaDeploy && !args.archiveType.equals("ear")) {
trace("Get existing jar hashes");
ApplicationJarHashesResponse applicationJarHashesResponse =
applicationJarHashes(args.appId, JarUtils.getJarHashes(archiveFile));
if (applicationJarHashesResponse.getJarHash().size() == 0) {
trace("No existing jars");
} else {
trace("Creating Delta2 archive for: " + archiveFile);
File archiveFile2 = JarUtils.createDeltaWarFile(applicationJarHashesResponse.getJarHash(), archiveFile,
archiveFile.getParent());
// Delete the old delta archive
if (deployDelta) {
archiveFile.delete();
}
archiveFile = archiveFile2;
deployJarDelta = true;
}
}
if (deployDelta || deployJarDelta) {
trace("Uploading delta archive: " + archiveFile);
}
File archiveFileSrc = args.srcFile;
long uploadSize = archiveFile.length();
if (archiveFileSrc != null) {
uploadSize += archiveFileSrc.length();
}
fileParams.put("archive", archiveFile);
params.put("archive_type", args.archiveType);
params.put("create", Boolean.valueOf(args.create).toString());
if (args.environment != null) {
params.put("environment", args.environment);
}
if (args.description != null) {
params.put("description", args.description);
}
if (archiveFileSrc != null) {
fileParams.put("src", archiveFileSrc);
}
params.put("parameters", createParameter(args.parameters));
params.put("variables", createParameter(args.variables));
// extend the deploy invocation timeout to 4 hours
long expireTime = System.currentTimeMillis() + 4 * 60 * 60 * 1000;
params.put("expires", Long.toString(expireTime / 1000));
String url = getApiUrl("application.deployArchive").toString();
params.put("action", "application.deployArchive");
String response = executeUpload(url, params, fileParams, args.progress);
try {
return (ApplicationDeployArchiveResponse) readResponse(response);
} finally {
// Delete the delta archive file
if (deployDelta || deployJarDelta) {
archiveFile.delete();
}
}
}
public ApplicationCheckSumsResponse applicationCheckSums(String appId) throws Exception {
return applicationCheckSums(appId, true);
}
public ApplicationCheckSumsResponse applicationCheckSums(String appId, boolean traceResponse) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
String url = getRequestURL("application.checkSums", params);
String response = executeRequest(url);
return (ApplicationCheckSumsResponse) readResponse(response);
}
public ApplicationScaleResponse applicationScale(String appId, int unit) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("unit", "" + unit);
params.put("app_id", appId);
String url = getRequestURL("application.scale", params);
String response = executeRequest(url);
return (ApplicationScaleResponse) readResponse(response);
}
public DatabaseCreateResponse databaseCreate(String domain, String dbId,
String username, String password) throws Exception {
return databaseCreate(domain, dbId, username, password, null);
}
public DatabaseCreateResponse databaseCreate(String domain, String dbId,
String username, String password, String plan) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
if (username != null)
params.put("database_username", username);
if (password != null)
params.put("database_password", password);
params.put("domain", domain);
if (plan != null)
params.put("database_plan", plan);
String url = getRequestURL("database.create", params);
String response = executeRequest(url);
return (DatabaseCreateResponse) readResponse(response);
}
public DatabaseDeleteResponse databaseDelete(String dbId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
String url = getRequestURL("database.delete", params);
String response = executeRequest(url);
return (DatabaseDeleteResponse) readResponse(response);
}
public DatabaseInfo databaseInfo(String dbId, boolean fetchPassword) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
params.put("fetch_password", ((Boolean) fetchPassword).toString());
String url = getRequestURL("database.info", params);
String response = executeRequest(url);
DatabaseInfoResponse apiResponse =
(DatabaseInfoResponse) readResponse(response);
return apiResponse.getDatabaseInfo();
}
/**
* Returns all the databases in all the account sthat you belong to.
* <p/>
* Short-hand for {@code databaseList(null)}.
*/
public DatabaseListResponse databaseList() throws Exception {
return databaseList(null);
}
/**
* Returns all the databases in the specified account.
*
* @param account if null, returns all the databases from all the accounts that you belong to.
* @since 1.1.3
*/
public DatabaseListResponse databaseList(String account) throws Exception {
Map<String, String> params = new HashMap<String, String>();
if (account != null) {
params.put("account", account);
}
String url = getRequestURL("database.list", params);
String response = executeRequest(url);
return (DatabaseListResponse) readResponse(response);
}
/**
* @deprecated use databaseUpdate
* @param dbId The database ID
* @param password The database password
* @return DatabaseSetPasswordResponse
* @throws Exception
*/
public DatabaseSetPasswordResponse databaseSetPassword(String dbId, String password) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
params.put("database_password", password);
String url = getRequestURL("database.setPassword", params);
String response = executeRequest(url);
return (DatabaseSetPasswordResponse) readResponse(response);
}
public DatabaseInfo databaseUpdate(String dbID, Map<String, String> parameters) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbID);
params.put("parameters", createParameter(parameters));
String url = getRequestURL("database.update", params);
String response = executeRequest(url);
return (DatabaseInfo)readResponse(response);
}
public DatabaseSnapshotListResponse databaseSnapshotList(String dbId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
String url = getRequestURL("database.snapshot.list", params);
String response = executeRequest(url);
return (DatabaseSnapshotListResponse) readResponse(response);
}
public DatabaseSnapshotDeleteResponse databaseSnapshotDelete(String dbId, String snapshotId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
params.put("snapshot_id", snapshotId);
String url = getRequestURL("database.snapshot.delete", params);
String response = executeRequest(url);
return (DatabaseSnapshotDeleteResponse) readResponse(response);
}
public DatabaseSnapshotDeployResponse databaseSnapshotDeploy(String dbId, String snapshotId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
params.put("snapshot_id", snapshotId);
String url = getRequestURL("database.snapshot.deploy", params);
String response = executeRequest(url);
return (DatabaseSnapshotDeployResponse) readResponse(response);
}
public DatabaseSnapshotInfo databaseSnapshotCreate(String dbId, String snapshotTitle) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
if (snapshotTitle != null) {
params.put("snapshot_title", snapshotTitle);
}
String url = getRequestURL("database.snapshot.create", params);
String response = executeRequest(url);
return (DatabaseSnapshotInfo) readResponse(response);
}
public DatabaseBackupListResponse databaseBackupList(String dbId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
String url = getRequestURL("database.backup.list", params);
String response = executeRequest(url);
return (DatabaseBackupListResponse) readResponse(response);
}
public DatabaseBackupResponse databaseBackupCreate(String dbId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
String url = getRequestURL("database.backup.create", params);
String response = executeRequest(url);
return (DatabaseBackupResponse) readResponse(response);
}
public DatabaseBackupResponse databaseBackupRestore(String dbId, String backupId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
params.put("backup_id", backupId);
String url = getRequestURL("database.backup.restore", params);
String response = executeRequest(url);
return (DatabaseBackupResponse) readResponse(response);
}
public DatabaseBackupResponse databaseBackupDelete(String dbId, String backupId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("database_id", dbId);
params.put("backup_id", backupId);
String url = getRequestURL("database.backup.delete", params);
String response = executeRequest(url);
return (DatabaseBackupResponse) readResponse(response);
}
public DatabaseClusterListResponse databaseClusterList(String account) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("account", account);
String url = getRequestURL("database.cluster.list", params);
String response = executeRequest(url);
return (DatabaseClusterListResponse) readResponse(response);
}
public AccountKeysResponse accountKeys(String domain, String user, String password) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("user", user);
params.put("password", password);
if (domain != null) {
params.put("domain", domain);
}
String url = getRequestURL("account.keys", params);
String response = executeRequest(url);
return (AccountKeysResponse) readResponse(response);
}
public AccountListResponse accountList() throws Exception {
Map<String, String> params = new HashMap<String, String>();
String url = getRequestURL("account.list", params);
String response = executeRequest(url);
return (AccountListResponse) readResponse(response);
}
public ApplicationConfiguration getApplicationConfiguration(String warFilePath, String account,
String[] environments) throws Exception {
ApplicationConfiguration appConfig;
File deployFile = asFile(warFilePath);
if (deployFile.exists()) {
appConfig = getAppConfig(deployFile, environments, new String[]{"deploy"});
} else {
throw new IllegalArgumentException("File not found: " + warFilePath);
}
String appid = appConfig.getApplicationId();
if (appid == null || appid.equals("")) {
throw new IllegalArgumentException("No application id specified");
}
String[] appIdParts = appid.split("/");
if (appIdParts.length < 2) {
if (account != null && !account.equals("")) {
appConfig.setApplicationId(account + "/" + appid);
} else {
throw new IllegalArgumentException("Application account not specified");
}
}
return appConfig;
}
public ConfigurationParametersUpdateResponse configurationParametersUpdate(String resourceId, String configType,
File resourceFile) throws Exception {
assertNotNull(resourceId,"resourceId");
assertNotNull(configType,"configType");
assertNotNull(resourceFile,"resourceFile");
Map<String, String> params = new HashMap<String, String>();
Map<String, File> fileParams = new HashMap<String, File>();
params.put("resource_id", resourceId);
params.put("config_type", configType);
fileParams.put("resources", resourceFile);
String url = getApiUrl("configuration.parameters.update").toString();
params.put("action", "configuration.parameters.update");
// use the upload method (POST) to handle the potentially large resource list
String response = executeUpload(url, params, fileParams, null);
return (ConfigurationParametersUpdateResponse) readResponse(response);
}
/**
* Updates the configuration of the given resource from the configuration object model.
*/
public ConfigurationParametersUpdateResponse configurationParametersUpdate(
String resourceId, String configType, ConfigParameters model) throws Exception {
File xmlFile = File.createTempFile("conf", "xml");
FileWriter fos = null;
try {
fos = new FileWriter(xmlFile);
fos.write(model.toXML());
fos.close();
return configurationParametersUpdate(resourceId,configType,xmlFile);
} finally {
IOUtils.closeQuietly(fos);
xmlFile.delete();
}
}
public ConfigurationParametersDeleteResponse configurationParametersDelete(String resourceId, String configType)
throws Exception {
assertNotNull(resourceId,"resourceId");
assertNotNull(configType,"configType");
Map<String, String> params = new HashMap<String, String>();
params.put("resource_id", resourceId);
params.put("config_type", configType);
String url = getRequestURL("configuration.parameters.delete", params);
String response = executeRequest(url);
return (ConfigurationParametersDeleteResponse) readResponse(response);
}
public ConfigurationParametersResponse configurationParameters(String resourceId, String configType)
throws Exception {
assertNotNull(resourceId,"resourceId");
assertNotNull(configType,"configType");
Map<String, String> params = new HashMap<String, String>();
params.put("resource_id", resourceId);
params.put("config_type", configType);
String url = getRequestURL("configuration.parameters", params);
String response = executeRequest(url);
return (ConfigurationParametersResponse) readResponse(response);
}
/**
* Perform {@link #configurationParameters(String, String)} and obtains the result as a data-bound object.
*/
public ConfigParameters configurationParametersAsObject(String resourceId, String configType) throws Exception {
return ConfigParameters.parse(configurationParameters(resourceId,configType).getConfiguration());
}
public ServiceListResponse serviceList(String account) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("account", account);
String url = getRequestURL("service.list", params);
String response = executeRequest(url);
return (ServiceListResponse) readResponse(response);
}
public ServiceSubscriptionInfo serviceSubscribe(String service, String plan, String account,
Map<String, String> settings) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("account", account);
params.put("service", service);
if (plan != null) {
params.put("plan", plan);
}
params.put("settings", createParameter(settings));
String url = getRequestURL("service.subscribe", params);
String response = executeRequest(url);
return ((ServiceSubscriptionResponse) readResponse(response)).getSubscription();
}
public ServiceSubscriptionDeleteResponse serviceUnSubscribe(String service, String subscriptionId)
throws Exception {
return serviceUnSubscribe(service, subscriptionId, null);
}
public ServiceSubscriptionDeleteResponse serviceUnSubscribe(String service, String subscriptionId, Map<String, String> settings)
throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("subscription_id", subscriptionId);
params.put("service", service);
params.put("settings", createParameter(settings));
String url = getRequestURL("service.unsubscribe", params);
String response = executeRequest(url);
return (ServiceSubscriptionDeleteResponse) readResponse(response);
}
public ServiceSubscriptionInfo serviceSubscriptionUpdate(String service, String plan, String subscriptionId,
Map<String, String> settings) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("subscription_id", subscriptionId);
params.put("service", service);
if (plan != null) {
params.put("plan", plan);
}
params.put("settings", createParameter(settings));
String url = getRequestURL("service.subscription.update", params);
String response = executeRequest(url);
return ((ServiceSubscriptionResponse) readResponse(response)).getSubscription();
}
public ServiceSubscriptionInfo serviceSubscriptionInfo(String service, String subscriptionId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("subscription_id", subscriptionId);
params.put("service", service);
String url = getRequestURL("service.subscription.info", params);
String response = executeRequest(url);
return ((ServiceSubscriptionResponse) readResponse(response)).getSubscription();
}
public ServiceSubscriptionListResponse serviceSubscriptionList(String account) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("account", account);
String url = getRequestURL("service.subscription.list", params);
String response = executeRequest(url);
return (ServiceSubscriptionListResponse) readResponse(response);
}
public ServiceResourceInfo serviceResourceInfo(String service, String resourceId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("service", service);
params.put("resource_id", resourceId);
String url = getRequestURL("service.resource.info", params);
String response = executeRequest(url);
return ((ServiceResourceResponse) readResponse(response)).getResource();
}
public ServiceResourceListResponse serviceResourceList(String service, String account, String resourceType)
throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("account", account);
params.put("service", service);
if (resourceType != null) {
params.put("resource_type", resourceType);
}
String url = getRequestURL("service.resource.list", params);
String response = executeRequest(url);
return (ServiceResourceListResponse) readResponse(response);
}
public ServiceResourceBindingListResponse resourceBindingList(String service, String resourceId) throws Exception
{
return resourceBindingList(service, resourceId, false);
}
public ServiceResourceBindingListResponse resourceBindingList(String service, String resourceId, boolean bidirectional) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("resource_id", resourceId);
params.put("service", service);
params.put("bidirectional", Boolean.toString(bidirectional));
String url = getRequestURL("resource.binding.list", params);
String response = executeRequest(url);
ServiceResourceBindingListResponse apiResponse =
(ServiceResourceBindingListResponse)readResponse(response);
return apiResponse;
}
public AccountRegionListResponse accountRegionList(String account, String service) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("account", account);
if (service != null)
params.put("service", service);
String url = getRequestURL("account.region.list", params);
String response = executeRequest(url);
return (AccountRegionListResponse)readResponse(response);
}
public ApplicationInstanceListResponse applicationInstanceList(String appId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
String url = getRequestURL("application.instance.list", params);
String response = executeRequest(url);
ApplicationInstanceListResponse apiResponse =
(ApplicationInstanceListResponse)readResponse(response);
return apiResponse;
}
public ApplicationInstanceStatusResponse applicationInstanceReplace(String instanceId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("instance_id", instanceId);
String url = getRequestURL("application.instance.replace", params);
String response = executeRequest(url);
ApplicationInstanceStatusResponse apiResponse =
(ApplicationInstanceStatusResponse)readResponse(response);
return apiResponse;
}
public ApplicationInstanceStatusResponse applicationInstanceRestart(String instanceId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("instance_id", instanceId);
String url = getRequestURL("application.instance.restart", params);
String response = executeRequest(url);
ApplicationInstanceStatusResponse apiResponse =
(ApplicationInstanceStatusResponse)readResponse(response);
return apiResponse;
}
public ApplicationInstanceStatusResponse applicationInstanceDelete(String instanceId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("instance_id", instanceId);
String url = getRequestURL("application.instance.delete", params);
String response = executeRequest(url);
ApplicationInstanceStatusResponse apiResponse =
(ApplicationInstanceStatusResponse)readResponse(response);
return apiResponse;
}
public com.cloudbees.api.ApplicationInstanceInfo applicationInstanceTagsUpdate(String instanceId, Map<String, String> tags, boolean replace) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("instance_id", instanceId);
params.put("reset", Boolean.toString(replace));
params.put("parameters", createParameter(tags));
String url = getApiUrl("application.instance.update").toString();
params.put("action", "application.instance.update");
// use the upload method (POST) to handle the potentially large tags payload
String response = executeUpload(url, params, new HashMap<String, File>(), null);
com.cloudbees.api.ApplicationInstanceInfo apiResponse =
(com.cloudbees.api.ApplicationInstanceInfo)readResponse(response);
return apiResponse;
}
public com.cloudbees.api.ApplicationInstanceInfo applicationInstanceInfo(String instanceId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("instance_id", instanceId);
String url = getRequestURL("application.instance.info", params);
String response = executeRequest(url);
com.cloudbees.api.ApplicationInstanceInfo apiResponse =
(com.cloudbees.api.ApplicationInstanceInfo)readResponse(response);
return apiResponse;
}
public ApplicationInstanceInvokeResponse applicationInstanceInvoke(String instanceId, String invoke, Map<String, String>parameters) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("instance_id", instanceId);
params.put("invoke",invoke);
params.put("parameters", createParameter(parameters));
String url = getRequestURL("application.instance.invoke", params);
String response = executeRequest(url);
ApplicationInstanceInvokeResponse apiResponse =
(ApplicationInstanceInvokeResponse)readResponse(response);
return apiResponse;
}
public void applicationInstanceTailLog(String instanceId, String logName, OutputStream out) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("instance_id", instanceId);
params.put("log_name", logName);
String url = getRequestURL("tail", params, false);
trace("API call: " + url);
InputStream input = executeCometRequest(url);
byte[] bytes = new byte[1024];
int numRead = input.read(bytes);
while (numRead != -1) {
out.write(bytes, 0, numRead);
numRead = input.read(bytes);
}
}
public ApplicationSnapshotListResponse applicationSnapshotList(String appId) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
String url = getRequestURL("application.snapshot.list", params);
String response = executeRequest(url);
return (ApplicationSnapshotListResponse) readResponse(response);
}
public ApplicationSnapshotStatusResponse applicationSnapshotDelete(String snapshotId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("snapshot_id", snapshotId);
String url = getRequestURL("application.snapshot.delete", params);
String response = executeRequest(url);
ApplicationSnapshotStatusResponse apiResponse =
(ApplicationSnapshotStatusResponse)readResponse(response);
return apiResponse;
}
public com.cloudbees.api.ApplicationSnapshotInfo applicationSnapshotInfo(String snapshotId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("snapshot_id", snapshotId);
String url = getRequestURL("application.snapshot.info", params);
String response = executeRequest(url);
com.cloudbees.api.ApplicationSnapshotInfo apiResponse =
(com.cloudbees.api.ApplicationSnapshotInfo)readResponse(response);
return apiResponse;
}
public ApplicationSnapshotStatusResponse applicationSnapshotUpdate(String snapshotId, Map<String, String> parameters) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("snapshot_id", snapshotId);
params.put("parameters", createParameter(parameters));
String url = getRequestURL("application.snapshot.update", params);
String response = executeRequest(url);
ApplicationSnapshotStatusResponse apiResponse =
(ApplicationSnapshotStatusResponse)readResponse(response);
return apiResponse;
}
public ApplicationStatusResponse applicationProxyUpdate(String appId, Map<String, String> parameters) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
params.put("parameters", createParameter(parameters));
String url = getRequestURL("application.proxy.update", params);
String response = executeRequest(url);
ApplicationStatusResponse apiResponse =
(ApplicationStatusResponse)readResponse(response);
return apiResponse;
}
public ApplicationConfigUpdateResponse applicationConfigUpdate(String appId, Map<String, String> parameters) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
params.put("parameters", createParameter(parameters));
String url = getRequestURL("application.config.update", params);
String response = executeRequest(url);
ApplicationConfigUpdateResponse apiResponse =
(ApplicationConfigUpdateResponse)readResponse(response);
return apiResponse;
}
public ServiceResourceBindResponse resourceBind(String fromService, String fromResourceId, String toService, String toResourceId, String alias, Map<String, String> settings) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("to_service", toService);
params.put("to_resource_id", toResourceId);
params.put("from_service", fromService);
params.put("from_resource_id", fromResourceId);
params.put("alias", alias);
params.put("settings", createParameter(settings));
String url = getRequestURL("service.resource.bind", params);
String response = executeRequest(url);
ServiceResourceBindResponse apiResponse =
(ServiceResourceBindResponse)readResponse(response);
return apiResponse;
}
public ServiceResourceUnBindResponse resourceUnBind( String service, String resourceId, String alias) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("alias", alias);
params.put("service", service);
params.put("resource_id", resourceId);
String url = getRequestURL("service.resource.unbind", params);
String response = executeRequest(url);
ServiceResourceUnBindResponse apiResponse =
(ServiceResourceUnBindResponse)readResponse(response);
return apiResponse;
}
public ServiceResourceInfo serviceResourceCreate(String service, String account, String resourceType, String resourceName, Map<String, String> settings) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("account", account);
params.put("service", service);
if (resourceType != null)
params.put("resource_type", resourceType);
params.put("resource_name", resourceName);
params.put("settings", createParameter(settings));
ServiceResourceResponse apiResponse = (ServiceResourceResponse) apiCall("service.resource.create", settings, params);
return apiResponse.getResource();
}
public ServiceResourceInfo serviceResourceUpdate(String service, String resourceId, Map<String, String> settings) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("service", service);
params.put("resource_id", resourceId);
params.put("settings", createParameter(settings));
ServiceResourceResponse apiResponse = (ServiceResourceResponse) apiCall("service.resource.update", settings, params);
return apiResponse.getResource();
}
public ServiceResourceDeleteResponse serviceResourceDelete(String service, String resourceId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("service", service);
params.put("resource_id", resourceId);
String url = getRequestURL("service.resource.delete", params);
String response = executeRequest(url);
ServiceResourceDeleteResponse apiResponse =
(ServiceResourceDeleteResponse)readResponse(response);
return apiResponse;
}
public ApplicationCreateResponse applicationCreate(String appId, Map<String, String> parameters) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
params.put("parameters", createParameter(parameters));
String url = getRequestURL("application.create", params);
String response = executeRequest(url);
ApplicationCreateResponse apiResponse =
(ApplicationCreateResponse)readResponse(response);
return apiResponse;
}
public ServerPoolInfo serverPoolCreate(String account, String poolName, Map<String, String> parameters) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("account", account);
params.put("pool_name", poolName);
params.put("parameters", createParameter(parameters));
String url = getRequestURL("server.pool.create", params);
String response = executeRequest(url);
ServerPoolInfo apiResponse =
(ServerPoolInfo)readResponse(response);
return apiResponse;
}
public ServerPoolInfo serverPoolInfo(String poolId) throws Exception
{
return serverPoolInfo(poolId, false);
}
public ServerPoolInfo serverPoolInfo(String poolId, boolean withApplications) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("pool_id", poolId);
if (withApplications)
params.put("with_applications", "true");
String url = getRequestURL("server.pool.info", params);
String response = executeRequest(url);
ServerPoolInfo apiResponse =
(ServerPoolInfo)readResponse(response);
return apiResponse;
}
public ServerPoolListResponse serverPoolList(String account) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("account", account);
String url = getRequestURL("server.pool.list", params);
String response = executeRequest(url);
ServerPoolListResponse apiResponse =
(ServerPoolListResponse)readResponse(response);
return apiResponse;
}
public ServerPoolDeleteResponse serverPoolDelete(String poolId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("pool_id", poolId);
String url = getRequestURL("server.pool.delete", params);
String response = executeRequest(url);
ServerPoolDeleteResponse apiResponse =
(ServerPoolDeleteResponse)readResponse(response);
return apiResponse;
}
public ServerInfo serverCreate(String poolId, Map<String, String> parameters) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("pool_id", poolId);
params.put("parameters", createParameter(parameters));
String url = getRequestURL("server.create", params);
String response = executeRequest(url);
ServerInfo apiResponse =
(ServerInfo)readResponse(response);
return apiResponse;
}
public ServerRestoreResponse serverRestore(String serverId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("server_id", serverId);
String url = getRequestURL("server.restore", params);
String response = executeRequest(url);
ServerRestoreResponse apiResponse =
(ServerRestoreResponse)readResponse(response);
return apiResponse;
}
public ServerInfo serverInfo(String serverId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("server_id", serverId);
String url = getRequestURL("server.info", params);
String response = executeRequest(url);
ServerInfo apiResponse =
(ServerInfo)readResponse(response);
return apiResponse;
}
public ServerStatusResponse serverStop(String serverId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("server_id", serverId);
String url = getRequestURL("server.stop", params);
String response = executeRequest(url);
ServerStatusResponse apiResponse =
(ServerStatusResponse)readResponse(response);
return apiResponse;
}
public ServerStatusResponse serverDelete(String serverId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("server_id", serverId);
String url = getRequestURL("server.delete", params);
String response = executeRequest(url);
ServerStatusResponse apiResponse =
(ServerStatusResponse)readResponse(response);
return apiResponse;
}
public ServerStatusResponse serverDeactivate(String serverId) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("server_id", serverId);
String url = getRequestURL("server.deactivate", params);
String response = executeRequest(url);
ServerStatusResponse apiResponse =
(ServerStatusResponse)readResponse(response);
return apiResponse;
}
public ServiceSubscriptionInvokeInfo serviceSubscriptionInvoke(String service, String subscriptionId, String invoke, Map<String, String> parameters) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("service", service);
params.put("subscription_id", subscriptionId);
params.put("invoke", invoke);
params.put("parameters", createParameter(parameters));
ServiceSubscriptionInvokeResponse apiResponse = (ServiceSubscriptionInvokeResponse) apiCall("service.subscription.invoke", parameters, params);
return apiResponse.getInvokeInfo();
}
public ServiceResourceInvokeInfo serviceResourceInvoke(String service, String resourceId, String invoke, Map<String, String> parameters) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("service", service);
params.put("resource_id", resourceId);
params.put("invoke", invoke);
params.put("parameters", createParameter(parameters));
ServiceResourceInvokeResponse apiResponse = (ServiceResourceInvokeResponse) apiCall("service.resource.invoke", parameters, params);
return apiResponse.getInvokeInfo();
}
public ApplicationCreateResponse applicationCreate(String appId, Map<String, String> parameters, Map<String, String> appParameters, Map<String, String> appVariables) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
params.put("parameters", createParameter(parameters));
params.put("app_parameters", createParameter(appParameters));
params.put("app_variables", createParameter(appVariables));
String url = getRequestURL("application.create", params);
String response = executeRequest(url);
ApplicationCreateResponse apiResponse =
(ApplicationCreateResponse)readResponse(response);
return apiResponse;
}
public List<ResourceSettings> applicationResources(String appId, String resourceType, String configType, String environment) throws Exception
{
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
if (environment != null)
params.put("environment", environment);
if (resourceType != null)
params.put("resource_type", resourceType);
if (configType != null)
params.put("config_type", configType);
String url = getRequestURL("application.resources", params);
String response = executeRequest(url);
List<ResourceSettings> apiResponse =
(List<ResourceSettings>)readResponse(response);
return apiResponse;
}
@Override
public String executeRequest(String url) throws Exception {
trace("API call: " + url);
String response = super.executeRequest(url);
traceResponse(response);
return response;
}
@Override
protected String executeUpload(String uploadURL, Map<String, String> params, Map<String, File> files, UploadProgress writeListener) throws Exception {
if (isVerbose()) {
String msg = "API call: " + uploadURL;
if (params != null && params.size() > 0) msg += ",P" + params;
if (files != null && files.size() > 0) msg += ",F" + files;
trace(msg);
}
return super.executeUpload(uploadURL, params, files, writeListener);
}
protected static ApplicationConfiguration getAppConfig(File deployZip, final String[] environments,
final String[] implicitEnvironments) throws IOException {
final ApplicationConfiguration applicationConfiguration = new ApplicationConfiguration();
FileInputStream fin = new FileInputStream(deployZip);
try {
ZipHelper.unzipFile(fin, new ZipHelper.ZipEntryHandler() {
public void unzip(ZipEntry entry, InputStream zis)
throws IOException {
if (entry.getName().equals("META-INF/stax-application.xml")
|| entry.getName().equals("WEB-INF/stax-web.xml")
|| entry.getName().equals("WEB-INF/cloudbees-web.xml")) {
AppConfigHelper.load(applicationConfiguration, zis, environments, implicitEnvironments);
}
}
}, false);
} finally {
fin.close();
}
return applicationConfiguration;
}
protected String createParameter(Map<String, String> parameters) {
if (parameters == null) {
parameters = new HashMap<String, String>();
}
JSONObject jsonObject = new JSONObject(parameters);
return jsonObject.toString();
}
public void tailLog(String appId, String logName, OutputStream out) throws Exception {
Map<String, String> params = new HashMap<String, String>();
params.put("app_id", appId);
params.put("log_name", logName);
String url = getRequestURL("tail", params, false);
trace("API call: " + url);
InputStream input = executeCometRequest(url);
byte[] bytes = new byte[1024];
int numRead = input.read(bytes);
while (numRead != -1) {
out.write(bytes, 0, numRead);
numRead = input.read(bytes);
}
}
protected Object apiCall(String apiMethod, Map<String, String> settings, Map<String, String> params) throws Exception {
Map<String, File> fileParams = new HashMap<String, File>();
if (settings != null) {
for (Map.Entry<String, String> entry : settings.entrySet()) {
String value = entry.getValue().toLowerCase();
int idx = value.startsWith("file://") ? 7 : 0;
if (idx == 0)
idx = value.startsWith("files://") ? 8 : 0;
if (idx > 0) {
File file = new File(entry.getValue().substring(idx));
fileParams.put("FILE." + entry.getKey(), file);
params.put("FILENAME." + entry.getKey(), file.getName());
}
}
}
String response;
// If files are to be uploaded use POST to upload
if (fileParams.size() > 0) {
String url = getApiUrl(apiMethod).toString();
params.put("action", apiMethod);
response = executeUpload(url, params, fileParams, new UploadProgress() {
public void handleBytesWritten(long l, long l1, long l2) {}
});
} else {
String url = getRequestURL(apiMethod, params);
response = executeRequest(url);
}
return readResponse(response);
}
public String call(String action, Map<String, String> params) throws Exception {
String url = getRequestURL(action, params);
String response = executeRequest(url);
return response;
}
protected XStream getXStream() throws Exception {
XStream xstream;
if (format.equals("json")) {
xstream = new XStream(new JettisonMappedXmlDriver()) {
protected MapperWrapper wrapMapper(MapperWrapper next) {
return new MapperWrapper(next) {
public boolean shouldSerializeMember(Class definedIn, String fieldName) {
return definedIn != Object.class && super.shouldSerializeMember(definedIn, fieldName);
}
};
}
};
} else if (format.equals("xml")) {
xstream = new XStream() {
protected MapperWrapper wrapMapper(MapperWrapper next) {
return new MapperWrapper(next) {
public boolean shouldSerializeMember(Class definedIn, String fieldName) {
return definedIn != Object.class && super.shouldSerializeMember(definedIn, fieldName);
}
};
}
};
} else {
throw new Exception("Unknown format: " + format);
}
xstream.processAnnotations(SayHelloResponse.class);
xstream.processAnnotations(ApplicationGetSourceUrlResponse.class);
xstream.processAnnotations(ApplicationDeleteResponse.class);
xstream.processAnnotations(ApplicationDeployResponse.class);
xstream.processAnnotations(ApplicationDeployArchiveResponse.class);
xstream.processAnnotations(ApplicationInstallResponse.class);
xstream.processAnnotations(ApplicationInfo.class);
xstream.processAnnotations(ApplicationInfoResponse.class);
xstream.processAnnotations(ApplicationListResponse.class);
xstream.processAnnotations(ApplicationRestartResponse.class);
xstream.processAnnotations(ApplicationStatusResponse.class);
xstream.processAnnotations(ApplicationSetMetaResponse.class);
xstream.processAnnotations(ApplicationCheckSumsResponse.class);
xstream.processAnnotations(ApplicationScaleResponse.class);
xstream.processAnnotations(ApplicationSnapshotInfo.class);
xstream.processAnnotations(ApplicationSnapshotListResponse.class);
xstream.processAnnotations(ApplicationSnapshotStatusResponse.class);
xstream.processAnnotations(DatabaseCreateResponse.class);
xstream.processAnnotations(DatabaseSetPasswordResponse.class);
xstream.processAnnotations(DatabaseDeleteResponse.class);
xstream.processAnnotations(DatabaseInfo.class);
xstream.processAnnotations(DatabaseInfoResponse.class);
xstream.processAnnotations(DatabaseListResponse.class);
xstream.processAnnotations(DatabaseSnapshotInfo.class);
xstream.processAnnotations(DatabaseSnapshotListResponse.class);
xstream.processAnnotations(DatabaseSnapshotDeployResponse.class);
xstream.processAnnotations(DatabaseSnapshotDeleteResponse.class);
xstream.processAnnotations(ErrorResponse.class);
xstream.processAnnotations(AccountKeysResponse.class);
xstream.processAnnotations(AccountInfo.class);
xstream.processAnnotations(AccountListResponse.class);
xstream.processAnnotations(ApplicationJarHashesResponse.class);
xstream.processAnnotations(ConfigurationParametersResponse.class);
xstream.processAnnotations(ConfigurationParametersUpdateResponse.class);
xstream.processAnnotations(ConfigurationParametersDeleteResponse.class);
xstream.processAnnotations(ServiceSubscriptionResponse.class);
xstream.processAnnotations(ServiceSubscriptionListResponse.class);
xstream.processAnnotations(ServiceSubscriptionDeleteResponse.class);
xstream.processAnnotations(ServiceResourceInfo.class);
xstream.processAnnotations(ServiceResourceResponse.class);
xstream.processAnnotations(ServiceResourceListResponse.class);
xstream.processAnnotations(ServiceResourceBindingListResponse.class);
xstream.processAnnotations(ResourceBindingInfo.class);
xstream.processAnnotations(AccountRegionInfo.class);
xstream.processAnnotations(AccountRegionListResponse.class);
xstream.processAnnotations(ApplicationInstanceInfo.class);
xstream.processAnnotations(ApplicationInstanceListResponse.class);
xstream.processAnnotations(ApplicationInstanceStatusResponse.class);
xstream.processAnnotations(ApplicationInstanceInvokeResponse.class);
xstream.processAnnotations(ApplicationConfigUpdateResponse.class);
xstream.processAnnotations(ServiceResourceDeleteResponse.class);
xstream.processAnnotations(ServiceResourceBindResponse.class);
xstream.processAnnotations(ServiceResourceUnBindResponse.class);
xstream.processAnnotations(RepositoryInfo.class);
xstream.processAnnotations(CIInfo.class);
xstream.processAnnotations(ApplicationCreateResponse.class);
xstream.processAnnotations(ServerPoolInfo.class);
xstream.processAnnotations(ServerPoolListResponse.class);
xstream.processAnnotations(ServerPoolDeleteResponse.class);
xstream.processAnnotations(ServerInfo.class);
xstream.processAnnotations(ServerStatusResponse.class);
xstream.processAnnotations(ServerRestoreResponse.class);
xstream.processAnnotations(ServerReinitResponse.class);
xstream.processAnnotations(ServiceResourceInvokeInfo.class);
xstream.processAnnotations(ServiceSubscriptionInvokeInfo.class);
xstream.processAnnotations(ServiceResourceResponse.class);
xstream.processAnnotations(ServiceResourceInvokeResponse.class);
xstream.processAnnotations(ServiceSubscriptionInvokeResponse.class);
xstream.processAnnotations(ServiceListResponse.class);
xstream.processAnnotations(ParameterSettings.class);
xstream.processAnnotations(ResourceSettings.class);
xstream.processAnnotations(DatabaseBackupInfo.class);
xstream.processAnnotations(DatabaseBackupListResponse.class);
xstream.processAnnotations(DatabaseBackupResponse.class);
xstream.processAnnotations(DatabaseClusterInfo.class);
xstream.processAnnotations(DatabaseClusterListResponse.class);
// Hack to fix backward compatibility
xstream.alias("net.stax.api.ApplicationStatusResponse", ApplicationStatusResponse.class);
xstream.alias("net.stax.api.ApplicationSetMetaResponse", ApplicationSetMetaResponse.class);
// BeesClient can be subtyped to offer more commands,
// yet those may live in separate classloader.
// use this.getClass().getClassLoader() to ensure
// that all the request/response classes resolve.
xstream.setClassLoader(getClass().getClassLoader());
return xstream;
}
protected Object readResponse(String response) throws Exception {
Object obj = getXStream().fromXML(response);
if (obj instanceof ErrorResponse) {
throw new BeesClientException((ErrorResponse) obj);
}
return obj;
}
public static String encodePassword(String password, String version) {
if ("0.1".equals(version)) {
try {
MessageDigest sha = MessageDigest.getInstance("SHA");
byte[] passwordDigest = sha.digest(password.getBytes("UTF8"));
String result = new BigInteger(1, passwordDigest).toString(16);
if (result.length() < 32) {
char[] padded = new char[32];
char[] raw = result.toCharArray();
Arrays.fill(padded, 0, 32 - raw.length, '0');
System.arraycopy(raw, 0, padded, 32 - raw.length, raw.length);
result = new String(padded);
}
return result;
} catch (NoSuchAlgorithmException e) {
throw new IllegalStateException("JVM is supposed to provide SHA instance of MessageDigest", e);
} catch (UnsupportedEncodingException e) {
throw new IllegalStateException("JVM is supposed to provide UTF-8 character encoding", e);
}
} else {
return password;
}
}
public void mainCall(String[] args) throws Exception {
Map<String, String> params = new HashMap<String, String>();
int argIndex = 0;
if (argIndex < args.length) {
String action = args[argIndex++];
for (; argIndex < args.length; argIndex++) {
String arg = args[argIndex];
String[] pair = arg.split("=", 2);
if (pair.length < 2) {
throw new BeesClient.UsageError("Malformed call parameter pair: " +
arg);
}
params.put(pair[0], pair[1]);
}
String response = call(action, params);
System.out.println(response);
} else {
throw new BeesClient.UsageError("Missing required action argument");
}
}
public void main(String[] args) throws Exception {
int argIndex = 0;
Map<String, String> options = new HashMap<String, String>();
for (; argIndex < args.length; argIndex++) {
String arg = args[argIndex];
if (arg.startsWith("-")) {
if (arg.equals("--call") || arg.equals("-c")) {
options.put("operation", arg);
} else if (arg.equals("--username") || arg.equals("-u")) {
options.put("username", arg);
} else if (arg.equals("--password") || arg.equals("-p")) {
options.put("password", arg);
} else if (arg.equals("--url") || arg.equals("-u")) {
options.put("url", arg);
} else {
throw new BeesClient.UsageError("Unsupported option: " + arg);
}
} else {
break;
}
}
String operation = getRequiredOption("operation", options);
BeesClient client =
new BeesClient(getRequiredOption("url", options),
getRequiredOption("username", options), getRequiredOption(
"password", options), "0.1", "1.0");
if (operation.equals("call")) {
String[] subArgs = new String[args.length - argIndex];
for (int i = 0; i < subArgs.length; i++) {
subArgs[i] = args[argIndex++];
}
client.main(subArgs);
}
}
private static String getRequiredOption(String optionName,
Map<String, String> options) throws BeesClient.UsageError {
if (options.containsKey(optionName)) {
return options.get(optionName);
} else {
throw new BeesClient.UsageError("Missing required flag: --" + optionName);
}
}
private static File asFile(String filePath) {
return filePath == null ? null : new File(filePath);
}
public static class UsageError extends Exception {
UsageError(String reason) {
super(reason);
}
}
class PatchMethod extends EntityEnclosingMethod {
PatchMethod() {
}
PatchMethod(String uri) {
super(uri);
}
@Override
public String getName() {
return "PATCH";
}
}
<T> T assertNotNull(T value, String arg) {
if (value==null)
throw new IllegalArgumentException("Null is not a valid value for the '"+arg+"' argument");
return value;
}
}