mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
580 lines
25 KiB
Java
580 lines
25 KiB
Java
/**
|
|
* Copyright (C) 2010 Cloud.com, Inc. All rights reserved.
|
|
*
|
|
* This software is licensed under the GNU General Public License v3 or later.
|
|
*
|
|
* It is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or any later version.
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
package com.cloud.api;
|
|
|
|
import java.io.UnsupportedEncodingException;
|
|
import java.net.URLDecoder;
|
|
import java.text.DateFormat;
|
|
import java.text.SimpleDateFormat;
|
|
import java.util.Date;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import org.apache.log4j.Logger;
|
|
|
|
import com.cloud.async.AsyncJobResult;
|
|
import com.cloud.async.AsyncJobVO;
|
|
import com.cloud.serializer.SerializerHelper;
|
|
import com.cloud.server.ManagementServer;
|
|
import com.cloud.user.Account;
|
|
import com.cloud.utils.Pair;
|
|
|
|
public abstract class BaseCmd {
|
|
private static final Logger s_logger = Logger.getLogger(BaseCmd.class.getName());
|
|
public static final int PROGRESS_INSTANCE_CREATED = 1;
|
|
|
|
public static final String RESPONSE_TYPE_XML = "xml";
|
|
public static final String RESPONSE_TYPE_JSON = "json";
|
|
|
|
public enum CommandType {
|
|
BOOLEAN, DATE, FLOAT, INTEGER, LIST, LONG, OBJECT, MAP, STRING, TZDATE
|
|
}
|
|
|
|
public enum Manager {
|
|
ConfigManager, ManagementServer, NetworkGroupManager, NetworkManager, StorageManager, UserVmManager
|
|
}
|
|
|
|
// FIXME: Extract these out into a separate file
|
|
// Client error codes
|
|
public static final int MALFORMED_PARAMETER_ERROR = 430;
|
|
public static final int VM_INVALID_PARAM_ERROR = 431;
|
|
public static final int NET_INVALID_PARAM_ERROR = 432;
|
|
public static final int VM_ALLOCATION_ERROR = 433;
|
|
public static final int IP_ALLOCATION_ERROR = 434;
|
|
public static final int SNAPSHOT_INVALID_PARAM_ERROR = 435;
|
|
public static final int PARAM_ERROR = 436;
|
|
|
|
// Server error codes
|
|
public static final int INTERNAL_ERROR = 530;
|
|
public static final int ACCOUNT_ERROR = 531;
|
|
public static final int UNSUPPORTED_ACTION_ERROR = 532;
|
|
|
|
public static final int VM_DEPLOY_ERROR = 540;
|
|
public static final int VM_DESTROY_ERROR = 541;
|
|
public static final int VM_REBOOT_ERROR = 542;
|
|
public static final int VM_START_ERROR = 543;
|
|
public static final int VM_STOP_ERROR = 544;
|
|
public static final int VM_RESET_PASSWORD_ERROR = 545;
|
|
public static final int VM_CHANGE_SERVICE_ERROR = 546;
|
|
public static final int VM_LIST_ERROR = 547;
|
|
public static final int VM_RECOVER_ERROR = 548;
|
|
public static final int SNAPSHOT_LIST_ERROR = 549;
|
|
public static final int CREATE_VOLUME_FROM_SNAPSHOT_ERROR = 550;
|
|
public static final int VM_INSUFFICIENT_CAPACITY = 551;
|
|
public static final int CREATE_PRIVATE_TEMPLATE_ERROR = 552;
|
|
public static final int VM_HOST_LICENSE_EXPIRED = 553;
|
|
|
|
public static final int NET_IP_ASSOC_ERROR = 560;
|
|
public static final int NET_IP_DIASSOC_ERROR = 561;
|
|
public static final int NET_CREATE_IPFW_RULE_ERROR = 562;
|
|
public static final int NET_DELETE_IPFW_RULE_ERROR = 563;
|
|
public static final int NET_CONFLICT_IPFW_RULE_ERROR = 564;
|
|
public static final int NET_CREATE_LB_RULE_ERROR = 566;
|
|
public static final int NET_DELETE_LB_RULE_ERROR = 567;
|
|
public static final int NET_CONFLICT_LB_RULE_ERROR = 568;
|
|
public static final int NET_LIST_ERROR = 570;
|
|
|
|
public static final int STORAGE_RESOURCE_IN_USE = 580;
|
|
|
|
|
|
public static final DateFormat INPUT_FORMAT = new SimpleDateFormat("yyyy-MM-dd");
|
|
private static final DateFormat _outputFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");
|
|
|
|
private Object _responseObject = null;
|
|
|
|
public abstract String getName();
|
|
public abstract String getResponse();
|
|
|
|
public Object getResponseObject() {
|
|
return _responseObject;
|
|
}
|
|
|
|
public void setResponseObject(Object responseObject) {
|
|
_responseObject = responseObject;
|
|
}
|
|
|
|
|
|
public String getDateString(Date date) {
|
|
if (date == null) {
|
|
return "";
|
|
}
|
|
String formattedString = null;
|
|
synchronized(_outputFormat) {
|
|
formattedString = _outputFormat.format(date);
|
|
}
|
|
return formattedString;
|
|
}
|
|
|
|
public Map<String, Object> validateParams(Map<String, String> params, boolean decode) {
|
|
// List<Pair<Enum, Boolean>> properties = getProperties();
|
|
|
|
// step 1 - all parameter names passed in will be converted to lowercase
|
|
Map<String, Object> processedParams = lowercaseParams(params, decode);
|
|
return processedParams;
|
|
|
|
/*
|
|
// step 2 - make sure all required params exist, and all existing params adhere to the appropriate data type
|
|
Map<String, Object> validatedParams = new HashMap<String, Object>();
|
|
for (Pair<Enum, Boolean> propertyPair : properties) {
|
|
Properties prop = (Properties)propertyPair.first();
|
|
Object param = processedParams.get(prop.getName());
|
|
// possible validation errors are
|
|
// - NULL (not specified)
|
|
// - MALFORMED
|
|
if (param != null) {
|
|
short propertyType = prop.getDataType();
|
|
String decodedParam = null;
|
|
if ((propertyType != TYPE_OBJECT) && (propertyType != TYPE_OBJECT_MAP)) {
|
|
decodedParam = (String)param;
|
|
if (decode) {
|
|
try {
|
|
decodedParam = URLDecoder.decode((String)param, "UTF-8");
|
|
} catch (UnsupportedEncodingException usex) {
|
|
s_logger.warn(prop.getName() + " could not be decoded, value = " + param);
|
|
throw new ServerApiException(PARAM_ERROR, prop.getName() + " could not be decoded");
|
|
}
|
|
}
|
|
}
|
|
|
|
switch (propertyType) {
|
|
case TYPE_INT:
|
|
try {
|
|
validatedParams.put(prop.getName(), Integer.valueOf(Integer.parseInt(decodedParam)));
|
|
} catch (NumberFormatException ex) {
|
|
s_logger.warn(prop.getName() + " (type is int) is malformed, value = " + decodedParam);
|
|
throw new ServerApiException(MALFORMED_PARAMETER_ERROR, prop.getName() + " is malformed");
|
|
}
|
|
break;
|
|
case TYPE_LONG:
|
|
try {
|
|
validatedParams.put(prop.getName(), Long.valueOf(Long.parseLong(decodedParam)));
|
|
} catch (NumberFormatException ex) {
|
|
s_logger.warn(prop.getName() + " (type is long) is malformed, value = " + decodedParam);
|
|
throw new ServerApiException(MALFORMED_PARAMETER_ERROR, prop.getName() + " is malformed");
|
|
}
|
|
break;
|
|
case TYPE_DATE:
|
|
try {
|
|
synchronized(_format) { // SimpleDataFormat is not thread safe, synchronize on it to avoid parse errors
|
|
validatedParams.put(prop.getName(), _format.parse(decodedParam));
|
|
}
|
|
} catch (ParseException ex) {
|
|
s_logger.warn(prop.getName() + " (type is date) is malformed, value = " + decodedParam);
|
|
throw new ServerApiException(MALFORMED_PARAMETER_ERROR, prop.getName() + " uses an unsupported date format");
|
|
}
|
|
break;
|
|
case TYPE_TZDATE:
|
|
try {
|
|
validatedParams.put(prop.getName(), DateUtil.parseTZDateString(decodedParam));
|
|
} catch (ParseException ex) {
|
|
s_logger.warn(prop.getName() + " (type is date) is malformed, value = " + decodedParam);
|
|
throw new ServerApiException(MALFORMED_PARAMETER_ERROR, prop.getName() + " uses an unsupported date format");
|
|
}
|
|
break;
|
|
case TYPE_FLOAT:
|
|
try {
|
|
validatedParams.put(prop.getName(), Float.valueOf(Float.parseFloat(decodedParam)));
|
|
} catch (NumberFormatException ex) {
|
|
s_logger.warn(prop.getName() + " (type is float) is malformed, value = " + decodedParam);
|
|
throw new ServerApiException(MALFORMED_PARAMETER_ERROR, prop.getName() + " is malformed");
|
|
}
|
|
break;
|
|
case TYPE_BOOLEAN:
|
|
validatedParams.put(prop.getName(), Boolean.valueOf(Boolean.parseBoolean(decodedParam)));
|
|
break;
|
|
case TYPE_STRING:
|
|
validatedParams.put(prop.getName(), decodedParam);
|
|
break;
|
|
default:
|
|
validatedParams.put(prop.getName(), param);
|
|
break;
|
|
}
|
|
} else if (propertyPair.second().booleanValue() == true) {
|
|
s_logger.warn("missing parameter, " + prop.getTagName() + " is not specified");
|
|
throw new ServerApiException(MALFORMED_PARAMETER_ERROR, prop.getTagName() + " is not specified");
|
|
}
|
|
}
|
|
|
|
return validatedParams;
|
|
*/
|
|
}
|
|
|
|
private Map<String, Object> lowercaseParams(Map<String, String> params, boolean decode) {
|
|
Map<String, Object> lowercaseParams = new HashMap<String, Object>();
|
|
for (String key : params.keySet()) {
|
|
lowercaseParams.put(key.toLowerCase(), params.get(key));
|
|
}
|
|
return lowercaseParams;
|
|
}
|
|
|
|
// FIXME: move this to a utils method so that maps can be unpacked and integer/long values can be appropriately cast
|
|
@SuppressWarnings("unchecked")
|
|
public Map<String, Object> unpackParams(Map<String, String> params) {
|
|
Map<String, Object> lowercaseParams = new HashMap<String, Object>();
|
|
for (String key : params.keySet()) {
|
|
int arrayStartIndex = key.indexOf('[');
|
|
int arrayStartLastIndex = key.lastIndexOf('[');
|
|
if (arrayStartIndex != arrayStartLastIndex) {
|
|
throw new ServerApiException(MALFORMED_PARAMETER_ERROR, "Unable to decode parameter " + key + "; if specifying an object array, please use parameter[index].field=XXX, e.g. userGroupList[0].group=httpGroup");
|
|
}
|
|
|
|
if (arrayStartIndex > 0) {
|
|
int arrayEndIndex = key.indexOf(']');
|
|
int arrayEndLastIndex = key.lastIndexOf(']');
|
|
if ((arrayEndIndex < arrayStartIndex) || (arrayEndIndex != arrayEndLastIndex)) {
|
|
// malformed parameter
|
|
throw new ServerApiException(MALFORMED_PARAMETER_ERROR, "Unable to decode parameter " + key + "; if specifying an object array, please use parameter[index].field=XXX, e.g. userGroupList[0].group=httpGroup");
|
|
}
|
|
|
|
// Now that we have an array object, check for a field name in the case of a complex object
|
|
int fieldIndex = key.indexOf('.');
|
|
String fieldName = null;
|
|
if (fieldIndex < arrayEndIndex) {
|
|
throw new ServerApiException(MALFORMED_PARAMETER_ERROR, "Unable to decode parameter " + key + "; if specifying an object array, please use parameter[index].field=XXX, e.g. userGroupList[0].group=httpGroup");
|
|
} else {
|
|
fieldName = key.substring(fieldIndex + 1);
|
|
}
|
|
|
|
// parse the parameter name as the text before the first '[' character
|
|
String paramName = key.substring(0, arrayStartIndex);
|
|
paramName = paramName.toLowerCase();
|
|
|
|
Map<Integer, Map> mapArray = null;
|
|
Map<String, Object> mapValue = null;
|
|
String indexStr = key.substring(arrayStartIndex+1, arrayEndIndex);
|
|
int index = 0;
|
|
boolean parsedIndex = false;
|
|
try {
|
|
if (indexStr != null) {
|
|
index = Integer.parseInt(indexStr);
|
|
parsedIndex = true;
|
|
}
|
|
} catch (NumberFormatException nfe) {
|
|
s_logger.warn("Invalid parameter " + key + " received, unable to parse object array, returning an error.");
|
|
}
|
|
|
|
if (!parsedIndex) {
|
|
throw new ServerApiException(MALFORMED_PARAMETER_ERROR, "Unable to decode parameter " + key + "; if specifying an object array, please use parameter[index].field=XXX, e.g. userGroupList[0].group=httpGroup");
|
|
}
|
|
|
|
Object value = lowercaseParams.get(paramName);
|
|
if (value == null) {
|
|
// for now, assume object array with sub fields
|
|
mapArray = new HashMap<Integer, Map>();
|
|
mapValue = new HashMap<String, Object>();
|
|
mapArray.put(Integer.valueOf(index), mapValue);
|
|
} else if (value instanceof Map) {
|
|
mapArray = (HashMap)value;
|
|
mapValue = mapArray.get(Integer.valueOf(index));
|
|
if (mapValue == null) {
|
|
mapValue = new HashMap<String, Object>();
|
|
mapArray.put(Integer.valueOf(index), mapValue);
|
|
}
|
|
}
|
|
|
|
// we are ready to store the value for a particular field into the map for this object
|
|
mapValue.put(fieldName, (String)params.get(key));
|
|
|
|
lowercaseParams.put(paramName, mapArray);
|
|
} else {
|
|
lowercaseParams.put(key.toLowerCase(), params.get(key));
|
|
}
|
|
}
|
|
return lowercaseParams;
|
|
}
|
|
|
|
public String buildResponse(ServerApiException apiException, String responseType) {
|
|
StringBuffer sb = new StringBuffer();
|
|
if (RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) {
|
|
// JSON response
|
|
sb.append("{ \"" + getName() + "\" : { \"errorcode\" : \"" + apiException.getErrorCode() + "\", \"description\" : \"" + apiException.getDescription() + "\" } }");
|
|
} else {
|
|
sb.append("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>");
|
|
sb.append("<" + getName() + ">");
|
|
sb.append("<errorcode>" + apiException.getErrorCode() + "</errorcode>");
|
|
sb.append("<description>" + escapeXml(apiException.getDescription()) + "</description>");
|
|
sb.append("</" + getName() + ">");
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
public String buildResponse(List<Pair<String, Object>> tagList, String responseType) {
|
|
StringBuffer sb = new StringBuffer();
|
|
|
|
// set up the return value with the name of the response
|
|
if (RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) {
|
|
sb.append("{ \"" + getName() + "\" : { ");
|
|
} else {
|
|
sb.append("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>");
|
|
sb.append("<" + getName() + ">");
|
|
}
|
|
|
|
int i = 0;
|
|
for (Pair<String, Object> tagData : tagList) {
|
|
String tagName = tagData.first();
|
|
Object tagValue = tagData.second();
|
|
if (tagValue instanceof Object[]) {
|
|
Object[] subObjects = (Object[])tagValue;
|
|
if (subObjects.length < 1) continue;
|
|
writeObjectArray(responseType, sb, i++, tagName, subObjects);
|
|
} else {
|
|
writeNameValuePair(sb, tagName, tagValue, responseType, i++);
|
|
}
|
|
}
|
|
|
|
// close the response
|
|
if (RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) {
|
|
sb.append("} }");
|
|
} else {
|
|
sb.append("</" + getName() + ">");
|
|
}
|
|
return sb.toString();
|
|
}
|
|
|
|
private void writeNameValuePair(StringBuffer sb, String tagName, Object tagValue, String responseType, int propertyCount) {
|
|
if (tagValue == null) {
|
|
return;
|
|
}
|
|
|
|
if (tagValue instanceof Object[]) {
|
|
Object[] subObjects = (Object[])tagValue;
|
|
if (subObjects.length < 1) return;
|
|
writeObjectArray(responseType, sb, propertyCount, tagName, subObjects);
|
|
} else {
|
|
if (RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) {
|
|
String seperator = ((propertyCount > 0) ? ", " : "");
|
|
sb.append(seperator + "\"" + tagName + "\" : \"" + escapeJSON(tagValue.toString()) + "\"");
|
|
} else {
|
|
sb.append("<" + tagName + ">" + escapeXml(tagValue.toString()) + "</" + tagName + ">");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void writeObjectArray(String responseType, StringBuffer sb, int propertyCount, String tagName, Object[] subObjects) {
|
|
if (RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) {
|
|
String separator = ((propertyCount > 0) ? ", " : "");
|
|
sb.append(separator);
|
|
}
|
|
int j = 0;
|
|
for (Object subObject : subObjects) {
|
|
if (subObject instanceof List) {
|
|
List subObjList = (List)subObject;
|
|
writeSubObject(sb, tagName, subObjList, responseType, j++);
|
|
}
|
|
}
|
|
|
|
if (RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) {
|
|
sb.append("]");
|
|
}
|
|
}
|
|
|
|
private void writeSubObject(StringBuffer sb, String tagName, List tagList, String responseType, int objectCount) {
|
|
if (RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) {
|
|
sb.append(((objectCount == 0) ? "\"" + tagName + "\" : [ { " : ", { "));
|
|
} else {
|
|
sb.append("<" + tagName + ">");
|
|
}
|
|
|
|
int i = 0;
|
|
for (Object tag : tagList) {
|
|
if (tag instanceof Pair) {
|
|
Pair nameValuePair = (Pair)tag;
|
|
writeNameValuePair(sb, (String)nameValuePair.first(), nameValuePair.second(), responseType, i++);
|
|
}
|
|
}
|
|
|
|
if (RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) {
|
|
sb.append("}");
|
|
} else {
|
|
sb.append("</" + tagName + ">");
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Escape xml response set to false by default. API commands to override this method to allow escaping
|
|
*/
|
|
public boolean requireXmlEscape() {
|
|
return true;
|
|
}
|
|
|
|
private String escapeXml(String xml){
|
|
if(!requireXmlEscape()){
|
|
return xml;
|
|
}
|
|
int iLen = xml.length();
|
|
if (iLen == 0)
|
|
return xml;
|
|
StringBuffer sOUT = new StringBuffer(iLen + 256);
|
|
int i = 0;
|
|
for (; i < iLen; i++) {
|
|
char c = xml.charAt(i);
|
|
if (c == '<')
|
|
sOUT.append("<");
|
|
else if (c == '>')
|
|
sOUT.append(">");
|
|
else if (c == '&')
|
|
sOUT.append("&");
|
|
else if (c == '"')
|
|
sOUT.append(""");
|
|
else if (c == '\'')
|
|
sOUT.append("'");
|
|
else
|
|
sOUT.append(c);
|
|
}
|
|
return sOUT.toString();
|
|
}
|
|
|
|
private static String escapeJSON(String str) {
|
|
if (str == null) {
|
|
return str;
|
|
}
|
|
|
|
return str.replace("\"", "\\\"");
|
|
}
|
|
|
|
protected long waitInstanceCreation(long jobId) {
|
|
ManagementServer mgr = getManagementServer();
|
|
|
|
long instanceId = 0;
|
|
AsyncJobVO job = null;
|
|
boolean interruped = false;
|
|
|
|
// as job may be executed in other management server, we need to do a database polling here
|
|
try {
|
|
boolean quit = false;
|
|
while(!quit) {
|
|
job = mgr.findAsyncJobById(jobId);
|
|
if(job == null) {
|
|
s_logger.error("Async command " + this.getClass().getName() + " waitInstanceCreation error: job-" + jobId + " no longer exists");
|
|
break;
|
|
}
|
|
|
|
switch(job.getStatus()) {
|
|
case AsyncJobResult.STATUS_IN_PROGRESS :
|
|
if(job.getProcessStatus() == BaseCmd.PROGRESS_INSTANCE_CREATED) {
|
|
Long id = (Long)SerializerHelper.fromSerializedString(job.getResult());
|
|
if(id != null) {
|
|
instanceId = id.longValue();
|
|
if(s_logger.isDebugEnabled())
|
|
s_logger.debug("Async command " + this.getClass().getName() + " succeeded in waiting for new instance to be created, instance Id: " + instanceId);
|
|
} else {
|
|
s_logger.warn("Async command " + this.getClass().getName() + " has new instance created, but value as null?");
|
|
}
|
|
quit = true;
|
|
}
|
|
break;
|
|
|
|
case AsyncJobResult.STATUS_SUCCEEDED :
|
|
instanceId = getInstanceIdFromJobSuccessResult(job.getResult());
|
|
quit = true;
|
|
break;
|
|
|
|
case AsyncJobResult.STATUS_FAILED :
|
|
s_logger.error("Async command " + this.getClass().getName() + " executing job-" + jobId + " failed, result: " + job.getResult());
|
|
quit = true;
|
|
break;
|
|
}
|
|
|
|
if(quit)
|
|
break;
|
|
|
|
try {
|
|
Thread.sleep(1000);
|
|
} catch (InterruptedException e) {
|
|
interruped = true;
|
|
}
|
|
}
|
|
} finally {
|
|
if(interruped)
|
|
Thread.currentThread().interrupt();
|
|
}
|
|
return instanceId;
|
|
}
|
|
|
|
protected long getInstanceIdFromJobSuccessResult(String result) {
|
|
s_logger.debug("getInstanceIdFromJobSuccessResult not overridden in subclass " + this.getClass().getName());
|
|
return 0;
|
|
}
|
|
|
|
public static boolean isAdmin(short accountType) {
|
|
return ((accountType == Account.ACCOUNT_TYPE_ADMIN) ||
|
|
(accountType == Account.ACCOUNT_TYPE_DOMAIN_ADMIN) ||
|
|
(accountType == Account.ACCOUNT_TYPE_READ_ONLY_ADMIN));
|
|
}
|
|
|
|
private Account getAccount(Map<String, Object> params) throws ServerApiException {
|
|
// FIXME: This should go into the context!
|
|
Long domainId = (Long) params.get("domainid");
|
|
Account account = (Account)params.get("accountobj");
|
|
String accountName = (String) params.get("account");
|
|
|
|
Long accountId = null;
|
|
Account finalAccount = null;
|
|
ManagementServer managementServer = getManagementServer();
|
|
if ((account == null) || isAdmin(account.getType())) {
|
|
if (domainId != null) {
|
|
if ((account != null) && !managementServer.isChildDomain(account.getDomainId(), domainId)) {
|
|
throw new ServerApiException(PARAM_ERROR, "Invalid domain id (" + domainId + ") ");
|
|
}
|
|
if (accountName != null) {
|
|
Account userAccount = managementServer.findActiveAccount(accountName, domainId);
|
|
if (userAccount == null) {
|
|
throw new ServerApiException(PARAM_ERROR, "Unable to find account " + accountName + " in domain " + domainId);
|
|
}
|
|
accountId = userAccount.getId();
|
|
}
|
|
} else {
|
|
accountId = ((account != null) ? account.getId() : null);
|
|
}
|
|
} else {
|
|
accountId = account.getId();
|
|
}
|
|
|
|
if (accountId != null) {
|
|
finalAccount = managementServer.findAccountById(accountId);
|
|
}
|
|
return finalAccount;
|
|
}
|
|
|
|
protected Long checkAccountPermissions(Map<String, Object> params,
|
|
long targetAccountId,
|
|
long targetDomainId,
|
|
String targetDesc,
|
|
long targetId)
|
|
throws ServerApiException
|
|
{
|
|
Long accountId = null;
|
|
|
|
Account account = getAccount(params);
|
|
if (account != null) {
|
|
if (!isAdmin(account.getType())) {
|
|
if (account.getId().longValue() != targetAccountId) {
|
|
throw new ServerApiException(BaseCmd.PARAM_ERROR, "Unable to find a " + targetDesc + " with id " + targetId + " for this account");
|
|
}
|
|
} else if (!getManagementServer().isChildDomain(account.getDomainId(), targetDomainId)) {
|
|
throw new ServerApiException(BaseCmd.PARAM_ERROR, "Unable to perform operation for " + targetDesc + " with id " + targetId + ", permission denied.");
|
|
}
|
|
accountId = account.getId();
|
|
}
|
|
|
|
return accountId;
|
|
}
|
|
}
|