From c211f0bbbe940ed3b9a6e9ef4b5a29be16062e85 Mon Sep 17 00:00:00 2001 From: Antonio Fornie Date: Fri, 7 Mar 2014 09:57:31 -0600 Subject: [PATCH] Dispatcher corrections, refactoring and tests Corrects problems from previous attempt. Fixes based on help comments from the community and conflict resolution Signed-off-by: Daan Hoogland --- .../apache/cloudstack/api/ApiConstants.java | 15 +- .../org/apache/cloudstack/api/BaseCmd.java | 203 ++++---- .../apache/cloudstack/api/BaseListCmd.java | 30 +- .../apache/cloudstack/api/BaseCmdTest.java | 69 +++ .../core/spring-server-core-misc-context.xml | 12 + server/src/com/cloud/api/ApiDispatcher.java | 492 +----------------- server/src/com/cloud/api/ApiServer.java | 374 ++++++------- server/src/com/cloud/api/ApiServlet.java | 133 ++--- .../api/dispatch/CommandCreationWorker.java | 56 ++ .../com/cloud/api/dispatch/DispatchChain.java | 40 ++ .../api/dispatch/DispatchChainFactory.java | 72 +++ .../com/cloud/api/dispatch/DispatchTask.java | 41 ++ .../cloud/api/dispatch/DispatchWorker.java | 30 ++ .../ParamGenericValidationWorker.java | 103 ++++ .../api/dispatch/ParamProcessWorker.java | 428 +++++++++++++++ .../cloud/api/dispatch/ParamUnpackWorker.java | 114 ++++ .../dispatch/SpecificCmdValidationWorker.java | 34 ++ .../network/as/AutoScaleManagerImpl.java | 466 +++++++++-------- .../VirtualNetworkApplianceManagerImpl.java | 2 - .../snapshot/SnapshotSchedulerImpl.java | 105 ++-- .../dispatch/CommandCreationWorkerTest.java | 48 ++ .../dispatch/DispatchChainFactoryTest.java | 55 ++ .../ParamGenericValidationWorkerTest.java | 173 ++++++ .../ParamProcessWorkerTest.java} | 19 +- .../SpecificCmdValidationWorkerTest.java | 48 ++ 25 files changed, 2070 insertions(+), 1092 deletions(-) create mode 100644 api/test/org/apache/cloudstack/api/BaseCmdTest.java create mode 100644 server/src/com/cloud/api/dispatch/CommandCreationWorker.java create mode 100644 server/src/com/cloud/api/dispatch/DispatchChain.java create mode 100644 server/src/com/cloud/api/dispatch/DispatchChainFactory.java create mode 100644 server/src/com/cloud/api/dispatch/DispatchTask.java create mode 100644 server/src/com/cloud/api/dispatch/DispatchWorker.java create mode 100644 server/src/com/cloud/api/dispatch/ParamGenericValidationWorker.java create mode 100644 server/src/com/cloud/api/dispatch/ParamProcessWorker.java create mode 100644 server/src/com/cloud/api/dispatch/ParamUnpackWorker.java create mode 100644 server/src/com/cloud/api/dispatch/SpecificCmdValidationWorker.java create mode 100644 server/test/com/cloud/api/dispatch/CommandCreationWorkerTest.java create mode 100644 server/test/com/cloud/api/dispatch/DispatchChainFactoryTest.java create mode 100644 server/test/com/cloud/api/dispatch/ParamGenericValidationWorkerTest.java rename server/test/com/cloud/api/{ApiDispatcherTest.java => dispatch/ParamProcessWorkerTest.java} (86%) create mode 100644 server/test/com/cloud/api/dispatch/SpecificCmdValidationWorkerTest.java diff --git a/api/src/org/apache/cloudstack/api/ApiConstants.java b/api/src/org/apache/cloudstack/api/ApiConstants.java index 14df653d5d2..f0de48e0c0e 100755 --- a/api/src/org/apache/cloudstack/api/ApiConstants.java +++ b/api/src/org/apache/cloudstack/api/ApiConstants.java @@ -23,7 +23,8 @@ public class ApiConstants { public static final String ACCOUNT_ID = "accountid"; public static final String ALGORITHM = "algorithm"; public static final String ALLOCATED_ONLY = "allocatedonly"; - public static final String API_KEY = "userapikey"; + public static final String API_KEY = "apikey"; + public static final String USER_API_KEY = "userapikey"; public static final String APPLIED = "applied"; public static final String AVAILABLE = "available"; public static final String BITS = "bits"; @@ -49,10 +50,16 @@ public class ApiConstants { public static final String CLUSTER_ID = "clusterid"; public static final String CLUSTER_NAME = "clustername"; public static final String CLUSTER_TYPE = "clustertype"; + public static final String COMMAND = "command"; + public static final String CMD_EVENT_TYPE = "cmdeventtype"; public static final String COMPONENT = "component"; public static final String CPU_NUMBER = "cpunumber"; public static final String CPU_SPEED = "cpuspeed"; public static final String CREATED = "created"; + public static final String CTX_ACCOUNT_ID = "ctxaccountid"; + public static final String CTX_USER_ID = "ctxuserid"; + public static final String CTXSTARTEVENTID = "ctxstarteventid"; + public static final String CTX_START_EVENT_ID = "ctxStartEventId"; public static final String CUSTOMIZED = "customized"; public static final String CUSTOMIZED_IOPS = "customizediops"; public static final String CUSTOM_ID = "customid"; @@ -79,6 +86,7 @@ public class ApiConstants { public static final String IP6_DNS2 = "ip6dns2"; public static final String DOMAIN = "domain"; public static final String DOMAIN_ID = "domainid"; + public static final String DOMAIN__ID = "domainId"; public static final String DURATION = "duration"; public static final String EMAIL = "email"; public static final String END_DATE = "enddate"; @@ -86,6 +94,7 @@ public class ApiConstants { public static final String END_IPV6 = "endipv6"; public static final String END_PORT = "endport"; public static final String ENTRY_TIME = "entrytime"; + public static final String EXPIRES = "expires"; public static final String FETCH_LATEST = "fetchlatest"; public static final String FIRSTNAME = "firstname"; public static final String FORCED = "forced"; @@ -209,8 +218,11 @@ public class ApiConstants { public static final String SENT = "sent"; public static final String SENT_BYTES = "sentbytes"; public static final String SERVICE_OFFERING_ID = "serviceofferingid"; + public static final String SESSIONKEY = "sessionkey"; public static final String SHOW_CAPACITIES = "showcapacities"; public static final String SHOW_REMOVED = "showremoved"; + public static final String SIGNATURE = "signature"; + public static final String SIGNATURE_VERSION = "signatureversion"; public static final String SIZE = "size"; public static final String SNAPSHOT_ID = "snapshotid"; public static final String SNAPSHOT_POLICY_ID = "snapshotpolicyid"; @@ -277,6 +289,7 @@ public class ApiConstants { public static final String NETWORKRATE = "networkrate"; public static final String HOST_TAGS = "hosttags"; public static final String SSH_KEYPAIR = "keypair"; + public static final String HTTPMETHOD = "httpmethod"; public static final String HOST_CPU_CAPACITY = "hostcpucapacity"; public static final String HOST_CPU_NUM = "hostcpunum"; public static final String HOST_MEM_CAPACITY = "hostmemcapacity"; diff --git a/api/src/org/apache/cloudstack/api/BaseCmd.java b/api/src/org/apache/cloudstack/api/BaseCmd.java index e869ddf9635..02250d7360f 100644 --- a/api/src/org/apache/cloudstack/api/BaseCmd.java +++ b/api/src/org/apache/cloudstack/api/BaseCmd.java @@ -17,22 +17,28 @@ package org.apache.cloudstack.api; +import java.lang.reflect.Field; import java.text.DateFormat; import java.text.SimpleDateFormat; +import java.util.ArrayList; import java.util.Date; import java.util.HashMap; +import java.util.List; import java.util.Map; import java.util.regex.Pattern; import javax.inject.Inject; +import org.apache.cloudstack.acl.RoleType; import org.apache.cloudstack.affinity.AffinityGroupService; import org.apache.cloudstack.alert.AlertService; +import org.apache.cloudstack.context.CallContext; import org.apache.cloudstack.network.element.InternalLoadBalancerElementService; import org.apache.cloudstack.network.lb.ApplicationLoadBalancerService; import org.apache.cloudstack.network.lb.InternalLoadBalancerVMService; import org.apache.cloudstack.query.QueryService; import org.apache.cloudstack.usage.UsageService; + import org.apache.log4j.Logger; import com.cloud.configuration.ConfigurationService; @@ -74,6 +80,7 @@ import com.cloud.user.Account; import com.cloud.user.AccountService; import com.cloud.user.DomainService; import com.cloud.user.ResourceLimitService; +import com.cloud.utils.ReflectUtil; import com.cloud.utils.db.EntityManager; import com.cloud.utils.db.UUIDManager; import com.cloud.vm.UserVmService; @@ -97,7 +104,9 @@ public abstract class BaseCmd { public static Pattern newInputDateFormat = Pattern.compile("[\\d]+-[\\d]+-[\\d]+ [\\d]+:[\\d]+:[\\d]+"); private static final DateFormat s_outputFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ"); - private Object _responseObject = null; + protected static final Map, List> fieldsForCmdClass = new HashMap, List>(); + + private Object _responseObject; private Map fullUrlParams; public enum HTTPMethod { @@ -205,7 +214,7 @@ public abstract class BaseCmd { return httpMethod; } - public void setHttpMethod(String method) { + public void setHttpMethod(final String method) { if (method != null) { if (method.equalsIgnoreCase("GET")) httpMethod = HTTPMethod.GET; @@ -227,12 +236,36 @@ public abstract class BaseCmd { return responseType; } - public void setResponseType(String responseType) { + public void setResponseType(final String responseType) { this.responseType = responseType; } + /** + * For some reason this method does not return the actual command name, but more a name that + * is used to create the response. So you can expect for a XCmd a value like xcmdresponse. Anyways + * this methods is used in too many places so for now instead of changing it we just create another + * method {@link BaseCmd#getActualCommandName()} that returns the value from {@link APICommand#name()} + * + * @return + */ public abstract String getCommandName(); + + /** + * Gets the CommandName based on the class annotations: the value from {@link APICommand#name()} + * + * @return the value from {@link APICommand#name()} + */ + public String getActualCommandName() { + String cmdName = null; + if (this.getClass().getAnnotation(APICommand.class) != null) { + cmdName = this.getClass().getAnnotation(APICommand.class).name(); + } else { + cmdName = this.getClass().getName(); + } + return cmdName; + } + /** * For commands the API framework needs to know the owner of the object being acted upon. This method is * used to determine that information. @@ -245,7 +278,7 @@ public abstract class BaseCmd { return _responseObject; } - public void setResponseObject(Object responseObject) { + public void setResponseObject(final Object responseObject) { _responseObject = responseObject; } @@ -253,7 +286,7 @@ public abstract class BaseCmd { return _mgr; } - public static String getDateString(Date date) { + public static String getDateString(final Date date) { if (date == null) { return ""; } @@ -264,101 +297,86 @@ public abstract class BaseCmd { return formattedString; } - // FIXME: move this to a utils method so that maps can be unpacked and integer/long values can be appropriately cast - @SuppressWarnings({"unchecked", "rawtypes"}) - public Map unpackParams(Map params) { - Map lowercaseParams = new HashMap(); - for (String key : params.keySet()) { - int arrayStartIndex = key.indexOf('['); - int arrayStartLastIndex = key.lastIndexOf('['); - if (arrayStartIndex != arrayStartLastIndex) { - throw new ServerApiException(ApiErrorCode.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"); + protected List getAllFieldsForClass(final Class clazz) { + List filteredFields = fieldsForCmdClass.get(clazz); + + // If list of fields was not cached yet + if (filteredFields == null) { + final List allFields = ReflectUtil.getAllFieldsForClass(this.getClass(), BaseCmd.class); + filteredFields = new ArrayList(); + + for (final Field field : allFields) { + final Parameter parameterAnnotation = field.getAnnotation(Parameter.class); + if ((parameterAnnotation != null) && parameterAnnotation.expose()) { + filteredFields.add(field); + } } - if (arrayStartIndex > 0) { - int arrayEndIndex = key.indexOf(']'); - int arrayEndLastIndex = key.lastIndexOf(']'); - if ((arrayEndIndex < arrayStartIndex) || (arrayEndIndex != arrayEndLastIndex)) { - // malformed parameter - throw new ServerApiException(ApiErrorCode.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(ApiErrorCode.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 mapArray = null; - Map 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(ApiErrorCode.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(); - mapValue = new HashMap(); - 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(); - 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, params.get(key)); - - lowercaseParams.put(paramName, mapArray); - } else { - lowercaseParams.put(key.toLowerCase(), params.get(key)); - } + // Cache the prepared list for future use + fieldsForCmdClass.put(clazz, filteredFields); } - return lowercaseParams; + return filteredFields; } - protected long getInstanceIdFromJobSuccessResult(String result) { + protected Account getCurrentContextAccount() { + return CallContext.current().getCallingAccount(); + } + + /** + * This method doesn't return all the @{link Parameter}, but only the ones exposed + * and allowed for current @{link RoleType}. This method will get the fields for a given + * Cmd class only once and never again, so in case of a dynamic update the result would + * be obsolete (this might be a plugin update. It is agreed upon that we will not do + * upgrades dynamically but in case we come back on that decision we need to revisit this) + * + * @return + */ + public List getParamFields() { + final List allFields = getAllFieldsForClass(this.getClass()); + final List validFields = new ArrayList(); + final Account caller = getCurrentContextAccount(); + + for (final Field field : allFields) { + final Parameter parameterAnnotation = field.getAnnotation(Parameter.class); + + //TODO: Annotate @Validate on API Cmd classes, FIXME how to process Validate + final RoleType[] allowedRoles = parameterAnnotation.authorized(); + boolean roleIsAllowed = true; + if (allowedRoles.length > 0) { + roleIsAllowed = false; + for (final RoleType allowedRole : allowedRoles) { + if (allowedRole.getValue() == caller.getType()) { + roleIsAllowed = true; + break; + } + } + } + + if (roleIsAllowed) { + validFields.add(field); + } else { + s_logger.debug("Ignoring paremeter " + parameterAnnotation.name() + " as the caller is not authorized to pass it in"); + } + } + + return validFields; + } + + protected long getInstanceIdFromJobSuccessResult(final String result) { s_logger.debug("getInstanceIdFromJobSuccessResult not overridden in subclass " + this.getClass().getName()); return 0; } - public static boolean isAdmin(short accountType) { + public static boolean isAdmin(final short accountType) { return ((accountType == Account.ACCOUNT_TYPE_ADMIN) || (accountType == Account.ACCOUNT_TYPE_RESOURCE_DOMAIN_ADMIN) || (accountType == Account.ACCOUNT_TYPE_DOMAIN_ADMIN) || (accountType == Account.ACCOUNT_TYPE_READ_ONLY_ADMIN)); } - public static boolean isRootAdmin(short accountType) { + public static boolean isRootAdmin(final short accountType) { return ((accountType == Account.ACCOUNT_TYPE_ADMIN)); } - public void setFullUrlParams(Map map) { + public void setFullUrlParams(final Map map) { fullUrlParams = map; } @@ -366,18 +384,18 @@ public abstract class BaseCmd { return fullUrlParams; } - public Long finalyzeAccountId(String accountName, Long domainId, Long projectId, boolean enabledOnly) { + public Long finalyzeAccountId(final String accountName, final Long domainId, final Long projectId, final boolean enabledOnly) { if (accountName != null) { if (domainId == null) { throw new InvalidParameterValueException("Account must be specified with domainId parameter"); } - Domain domain = _domainService.getDomain(domainId); + final Domain domain = _domainService.getDomain(domainId); if (domain == null) { throw new InvalidParameterValueException("Unable to find domain by id"); } - Account account = _accountService.getActiveAccountByName(accountName, domainId); + final Account account = _accountService.getActiveAccountByName(accountName, domainId); if (account != null && account.getType() != Account.ACCOUNT_TYPE_PROJECT) { if (!enabledOnly || account.getState() == Account.State.enabled) { return account.getId(); @@ -394,12 +412,12 @@ public abstract class BaseCmd { } if (projectId != null) { - Project project = _projectService.getProject(projectId); + final Project project = _projectService.getProject(projectId); if (project != null) { if (!enabledOnly || project.getState() == Project.State.Active) { return project.getProjectAccountId(); } else { - PermissionDeniedException ex = + final PermissionDeniedException ex = new PermissionDeniedException("Can't add resources to the project with specified projectId in state=" + project.getState() + " as it's no longer active"); ex.addProxyObject(project.getUuid(), "projectId"); @@ -412,6 +430,13 @@ public abstract class BaseCmd { return null; } + /** + * To be overwritten by any class who needs specific validation + */ + public void validateSpecificParameters(final Map params){ + // To be overwritten by any class who needs specific validation + } + /** * display flag is used to control the display of the resource only to the end user. It doesnt affect Root Admin. * @return display flag diff --git a/api/src/org/apache/cloudstack/api/BaseListCmd.java b/api/src/org/apache/cloudstack/api/BaseListCmd.java index c1a4b4c440f..f2800035ad5 100644 --- a/api/src/org/apache/cloudstack/api/BaseListCmd.java +++ b/api/src/org/apache/cloudstack/api/BaseListCmd.java @@ -16,7 +16,10 @@ // under the License. package org.apache.cloudstack.api; +import java.util.Map; + import com.cloud.exception.InvalidParameterValueException; +import com.cloud.utils.exception.CSExceptionErrorCode; public abstract class BaseListCmd extends BaseCmd { @@ -83,7 +86,7 @@ public abstract class BaseListCmd extends BaseCmd { public Long getPageSizeVal() { Long defaultPageSize = s_maxPageSize; - Integer pageSizeInt = getPageSize(); + final Integer pageSizeInt = getPageSize(); if (pageSizeInt != null) { defaultPageSize = pageSizeInt.longValue(); } @@ -96,12 +99,12 @@ public abstract class BaseListCmd extends BaseCmd { public Long getStartIndex() { Long startIndex = Long.valueOf(0); - Long pageSizeVal = getPageSizeVal(); + final Long pageSizeVal = getPageSizeVal(); if (pageSizeVal == null) { startIndex = null; } else if (page != null) { - int pageNum = page.intValue(); + final int pageNum = page.intValue(); if (pageNum > 0) { startIndex = Long.valueOf(pageSizeVal * (pageNum - 1)); } @@ -112,4 +115,25 @@ public abstract class BaseListCmd extends BaseCmd { public ApiCommandJobType getInstanceType() { return ApiCommandJobType.None; } + + @Override + public void validateSpecificParameters(final Map params){ + super.validateSpecificParameters(params); + + final Object pageSizeObj = params.get(ApiConstants.PAGE_SIZE); + Long pageSize = null; + if (pageSizeObj != null) { + pageSize = Long.valueOf((String)pageSizeObj); + } + + if (params.get(ApiConstants.PAGE) == null && + pageSize != null && + !pageSize.equals(BaseListCmd.s_pageSizeUnlimited)) { + final ServerApiException ex = new ServerApiException(ApiErrorCode.PARAM_ERROR, "\"page\" parameter is required when \"pagesize\" is specified"); + ex.setCSErrorCode(CSExceptionErrorCode.getCSErrCode(ex.getClass().getName())); + throw ex; + } else if (pageSize == null && (params.get(ApiConstants.PAGE) != null)) { + throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "\"pagesize\" parameter is required when \"page\" is specified"); + } + } } diff --git a/api/test/org/apache/cloudstack/api/BaseCmdTest.java b/api/test/org/apache/cloudstack/api/BaseCmdTest.java new file mode 100644 index 00000000000..edf5776d2b3 --- /dev/null +++ b/api/test/org/apache/cloudstack/api/BaseCmdTest.java @@ -0,0 +1,69 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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 org.apache.cloudstack.api; + +import static org.junit.Assert.assertEquals; + +import org.junit.Test; + +import com.cloud.exception.ConcurrentOperationException; +import com.cloud.exception.InsufficientCapacityException; +import com.cloud.exception.NetworkRuleConflictException; +import com.cloud.exception.ResourceAllocationException; +import com.cloud.exception.ResourceUnavailableException; + +public class BaseCmdTest { + + private static final String NON_EXPECTED_COMMAND_NAME = "Non expected command name"; + protected static final String CMD1_NAME = "Cmd1Name"; + protected static final String CMD2_NAME = "Cmd2Name"; + protected static final String CMD1_RESPONSE = "cmd1response"; + protected static final String CMD2_RESPONSE = "cmd2response"; + + @Test + public void testGetActualCommandName(){ + BaseCmd cmd1 = new Cmd1(); + BaseCmd cmd2 = new Cmd2(); + + assertEquals(NON_EXPECTED_COMMAND_NAME, CMD1_NAME, cmd1.getActualCommandName()); + assertEquals(NON_EXPECTED_COMMAND_NAME, CMD2_NAME, cmd2.getActualCommandName()); + } +} + +@APICommand(name=BaseCmdTest.CMD1_NAME, responseObject=BaseResponse.class) +class Cmd1 extends BaseCmd { + @Override + public void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException, ResourceAllocationException, + NetworkRuleConflictException { + } + @Override + public String getCommandName() { + return BaseCmdTest.CMD1_RESPONSE; + } + @Override + public long getEntityOwnerId() { + return 0; + } +} + +@APICommand(name=BaseCmdTest.CMD2_NAME, responseObject=BaseResponse.class) +class Cmd2 extends Cmd1 { + @Override + public String getCommandName() { + return BaseCmdTest.CMD2_RESPONSE; + } +} diff --git a/server/resources/META-INF/cloudstack/core/spring-server-core-misc-context.xml b/server/resources/META-INF/cloudstack/core/spring-server-core-misc-context.xml index fd2f5fbb3fd..91401e33549 100644 --- a/server/resources/META-INF/cloudstack/core/spring-server-core-misc-context.xml +++ b/server/resources/META-INF/cloudstack/core/spring-server-core-misc-context.xml @@ -50,6 +50,18 @@ + + + + + + + + + + + + diff --git a/server/src/com/cloud/api/ApiDispatcher.java b/server/src/com/cloud/api/ApiDispatcher.java index 5bdefe74306..5d4b4d3368c 100755 --- a/server/src/com/cloud/api/ApiDispatcher.java +++ b/server/src/com/cloud/api/ApiDispatcher.java @@ -16,127 +16,72 @@ // under the License. package com.cloud.api; -import static org.apache.commons.lang.StringUtils.isNotBlank; - -import java.lang.reflect.Field; -import java.text.DateFormat; -import java.text.ParseException; -import java.util.ArrayList; -import java.util.Calendar; -import java.util.Date; -import java.util.HashMap; -import java.util.List; import java.util.Map; -import java.util.StringTokenizer; -import java.util.regex.Matcher; import javax.annotation.PostConstruct; import javax.inject.Inject; -import org.apache.cloudstack.acl.ControlledEntity; -import org.apache.cloudstack.acl.InfrastructureEntity; -import org.apache.cloudstack.acl.RoleType; -import org.apache.cloudstack.acl.SecurityChecker.AccessType; -import org.apache.cloudstack.api.ACL; import org.apache.cloudstack.api.ApiConstants; -import org.apache.cloudstack.api.ApiErrorCode; import org.apache.cloudstack.api.BaseAsyncCmd; import org.apache.cloudstack.api.BaseAsyncCreateCmd; import org.apache.cloudstack.api.BaseAsyncCustomIdCmd; import org.apache.cloudstack.api.BaseCmd; -import org.apache.cloudstack.api.BaseCmd.CommandType; import org.apache.cloudstack.api.BaseCustomIdCmd; -import org.apache.cloudstack.api.BaseListCmd; -import org.apache.cloudstack.api.EntityReference; -import org.apache.cloudstack.api.InternalIdentity; -import org.apache.cloudstack.api.Parameter; -import org.apache.cloudstack.api.ServerApiException; -import org.apache.cloudstack.api.command.admin.resource.ArchiveAlertsCmd; -import org.apache.cloudstack.api.command.admin.resource.DeleteAlertsCmd; -import org.apache.cloudstack.api.command.user.event.ArchiveEventsCmd; -import org.apache.cloudstack.api.command.user.event.DeleteEventsCmd; -import org.apache.cloudstack.api.command.user.event.ListEventsCmd; import org.apache.cloudstack.context.CallContext; import org.apache.cloudstack.framework.jobs.AsyncJob; import org.apache.cloudstack.framework.jobs.AsyncJobManager; import org.apache.log4j.Logger; -import com.cloud.exception.InvalidParameterValueException; -import com.cloud.user.Account; -import com.cloud.user.AccountManager; -import com.cloud.utils.DateUtil; -import com.cloud.utils.ReflectUtil; -import com.cloud.utils.db.EntityManager; -import com.cloud.utils.exception.CSExceptionErrorCode; -import com.cloud.utils.exception.CloudRuntimeException; +import com.cloud.api.dispatch.DispatchChain; +import com.cloud.api.dispatch.DispatchChainFactory; +import com.cloud.api.dispatch.DispatchTask; public class ApiDispatcher { private static final Logger s_logger = Logger.getLogger(ApiDispatcher.class.getName()); Long _createSnapshotQueueSizeLimit; - @Inject - AsyncJobManager _asyncMgr = null; - @Inject - AccountManager _accountMgr = null; - @Inject - EntityManager _entityMgr = null; - private static ApiDispatcher s_instance; + @Inject + AsyncJobManager _asyncMgr; - public static ApiDispatcher getInstance() { - return s_instance; - } + @Inject() + protected DispatchChainFactory dispatchChainFactory; + + protected DispatchChain standardDispatchChain; + + protected DispatchChain asyncCreationDispatchChain; public ApiDispatcher() { } @PostConstruct - void init() { - s_instance = this; + public void setup() { + standardDispatchChain = dispatchChainFactory.getStandardDispatchChain(); + asyncCreationDispatchChain = dispatchChainFactory.getAsyncCreationDispatchChain(); } - public void setCreateSnapshotQueueSizeLimit(Long snapshotLimit) { + public void setCreateSnapshotQueueSizeLimit(final Long snapshotLimit) { _createSnapshotQueueSizeLimit = snapshotLimit; } - public void dispatchCreateCmd(BaseAsyncCreateCmd cmd, Map params) throws Exception { - processParameters(cmd, params); + + public void dispatchCreateCmd(final BaseAsyncCreateCmd cmd, final Map params) throws Exception { + asyncCreationDispatchChain.dispatch(new DispatchTask(cmd, params)); CallContext.current().setEventDisplayEnabled(cmd.isDisplayResourceEnabled()); - cmd.create(); - } - private void doAccessChecks(BaseCmd cmd, Map entitiesToAccess) { - Account caller = CallContext.current().getCallingAccount(); - Account owner = _accountMgr.getActiveAccountById(cmd.getEntityOwnerId()); + public void dispatch(final BaseCmd cmd, final Map params, final boolean execute) throws Exception { + // Let the chain of responsibility dispatch gradually + standardDispatchChain.dispatch(new DispatchTask(cmd, params)); - if (cmd instanceof BaseAsyncCreateCmd) { - //check that caller can access the owner account. - _accountMgr.checkAccess(caller, null, true, owner); - } - - if (!entitiesToAccess.isEmpty()) { - //check that caller can access the owner account. - _accountMgr.checkAccess(caller, null, true, owner); - for (Object entity : entitiesToAccess.keySet()) { - if (entity instanceof ControlledEntity) { - _accountMgr.checkAccess(caller, entitiesToAccess.get(entity), true, (ControlledEntity)entity); - } else if (entity instanceof InfrastructureEntity) { - //FIXME: Move this code in adapter, remove code from Account manager - } - } - } - } - - public void dispatch(BaseCmd cmd, Map params, boolean execute) throws Exception { - processParameters(cmd, params); - CallContext ctx = CallContext.current(); + final CallContext ctx = CallContext.current(); ctx.setEventDisplayEnabled(cmd.isDisplayResourceEnabled()); + // TODO This if shouldn't be here. Use polymorphism and move it to validateSpecificParameters if (cmd instanceof BaseAsyncCmd) { - BaseAsyncCmd asyncCmd = (BaseAsyncCmd)cmd; - String startEventId = params.get("ctxStartEventId"); + final BaseAsyncCmd asyncCmd = (BaseAsyncCmd)cmd; + final String startEventId = params.get(ApiConstants.CTX_START_EVENT_ID); ctx.setStartEventId(Long.valueOf(startEventId)); // Synchronise job on the object if needed @@ -160,6 +105,7 @@ public class ApiDispatcher { } } + // TODO This if shouldn't be here. Use polymorphism and move it to validateSpecificParameters if (cmd instanceof BaseAsyncCustomIdCmd) { ((BaseAsyncCustomIdCmd)cmd).checkUuid(); } else if (cmd instanceof BaseCustomIdCmd) { @@ -167,392 +113,6 @@ public class ApiDispatcher { } cmd.execute(); - } - @SuppressWarnings({"unchecked", "rawtypes"}) - public static void processParameters(BaseCmd cmd, Map params) { - Map entitiesToAccess = new HashMap(); - Map unpackedParams = cmd.unpackParams(params); - - if (cmd instanceof BaseListCmd) { - Object pageSizeObj = unpackedParams.get(ApiConstants.PAGE_SIZE); - Long pageSize = null; - if (pageSizeObj != null) { - pageSize = Long.valueOf((String)pageSizeObj); - } - - if ((unpackedParams.get(ApiConstants.PAGE) == null) && (pageSize != null && !pageSize.equals(BaseListCmd.s_pageSizeUnlimited))) { - ServerApiException ex = new ServerApiException(ApiErrorCode.PARAM_ERROR, "\"page\" parameter is required when \"pagesize\" is specified"); - ex.setCSErrorCode(CSExceptionErrorCode.getCSErrCode(ex.getClass().getName())); - throw ex; - } else if (pageSize == null && (unpackedParams.get(ApiConstants.PAGE) != null)) { - throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "\"pagesize\" parameter is required when \"page\" is specified"); - } - } - - List fields = ReflectUtil.getAllFieldsForClass(cmd.getClass(), BaseCmd.class); - - for (Field field : fields) { - Parameter parameterAnnotation = field.getAnnotation(Parameter.class); - if ((parameterAnnotation == null) || !parameterAnnotation.expose()) { - continue; - } - - //TODO: Annotate @Validate on API Cmd classes, FIXME how to process Validate - RoleType[] allowedRoles = parameterAnnotation.authorized(); - if (allowedRoles.length > 0) { - boolean permittedParameter = false; - Account caller = CallContext.current().getCallingAccount(); - for (RoleType allowedRole : allowedRoles) { - if (allowedRole.getValue() == caller.getType()) { - permittedParameter = true; - break; - } - } - if (!permittedParameter) { - s_logger.debug("Ignoring paremeter " + parameterAnnotation.name() + " as the caller is not authorized to pass it in"); - continue; - } - } - - Object paramObj = unpackedParams.get(parameterAnnotation.name()); - if (paramObj == null) { - if (parameterAnnotation.required()) { - throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Unable to execute API command " + - cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8) + " due to missing parameter " + parameterAnnotation.name()); - } - continue; - } - - // marshall the parameter into the correct type and set the field value - try { - setFieldValue(field, cmd, paramObj, parameterAnnotation); - } catch (IllegalArgumentException argEx) { - if (s_logger.isDebugEnabled()) { - s_logger.debug("Unable to execute API command " + cmd.getCommandName() + " due to invalid value " + paramObj + " for parameter " + - parameterAnnotation.name()); - } - throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Unable to execute API command " + - cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8) + " due to invalid value " + paramObj + " for parameter " + - parameterAnnotation.name()); - } catch (ParseException parseEx) { - if (s_logger.isDebugEnabled()) { - s_logger.debug("Invalid date parameter " + paramObj + " passed to command " + cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8)); - } - throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Unable to parse date " + paramObj + " for command " + - cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8) + ", please pass dates in the format mentioned in the api documentation"); - } catch (InvalidParameterValueException invEx) { - throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Unable to execute API command " + - cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8) + " due to invalid value. " + invEx.getMessage()); - } catch (CloudRuntimeException cloudEx) { - s_logger.error("CloudRuntimeException", cloudEx); - // FIXME: Better error message? This only happens if the API command is not executable, which typically - //means - // there was - // and IllegalAccessException setting one of the parameters. - throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Internal error executing API command " + - cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8)); - } - - //check access on the resource this field points to - try { - ACL checkAccess = field.getAnnotation(ACL.class); - CommandType fieldType = parameterAnnotation.type(); - - if (checkAccess != null) { - // Verify that caller can perform actions in behalf of vm owner - //acumulate all Controlled Entities together. - - //parse the array of resource types and in case of map check access on key or value or both as specified in @acl - //implement external dao for classes that need findByName - //for maps, specify access to be checkd on key or value. - - // find the controlled entity DBid by uuid - if (parameterAnnotation.entityType() != null) { - Class[] entityList = parameterAnnotation.entityType()[0].getAnnotation(EntityReference.class).value(); - - for (Class entity : entityList) { - // Check if the parameter type is a single - // Id or list of id's/name's - switch (fieldType) { - case LIST: - CommandType listType = parameterAnnotation.collectionType(); - switch (listType) { - case LONG: - case UUID: - List listParam = (List)field.get(cmd); - for (Long entityId : listParam) { - Object entityObj = s_instance._entityMgr.findById(entity, entityId); - entitiesToAccess.put(entityObj, checkAccess.accessType()); - } - break; - /* - * case STRING: List listParam = - * new ArrayList(); listParam = - * (List)field.get(cmd); for(String - * entityName: listParam){ - * ControlledEntity entityObj = - * (ControlledEntity - * )daoClassInstance(entityId); - * entitiesToAccess.add(entityObj); } - * break; - */ - default: - break; - } - break; - case LONG: - case UUID: - Object entityObj = s_instance._entityMgr.findById(entity, (Long)field.get(cmd)); - entitiesToAccess.put(entityObj, checkAccess.accessType()); - break; - default: - break; - } - - if (ControlledEntity.class.isAssignableFrom(entity)) { - if (s_logger.isDebugEnabled()) { - s_logger.debug("ControlledEntity name is:" + entity.getName()); - } - } - - if (InfrastructureEntity.class.isAssignableFrom(entity)) { - if (s_logger.isDebugEnabled()) { - s_logger.debug("InfrastructureEntity name is:" + entity.getName()); - } - } - } - - } - - } - - } catch (IllegalArgumentException e) { - s_logger.error("Error initializing command " + cmd.getCommandName() + ", field " + field.getName() + " is not accessible."); - throw new CloudRuntimeException("Internal error initializing parameters for command " + cmd.getCommandName() + " [field " + field.getName() + - " is not accessible]"); - } catch (IllegalAccessException e) { - s_logger.error("Error initializing command " + cmd.getCommandName() + ", field " + field.getName() + " is not accessible."); - throw new CloudRuntimeException("Internal error initializing parameters for command " + cmd.getCommandName() + " [field " + field.getName() + - " is not accessible]"); - } - - } - - //check access on the entities. - getInstance().doAccessChecks(cmd, entitiesToAccess); - - } - - private static Long translateUuidToInternalId(String uuid, Parameter annotation) { - if (uuid.equals("-1")) { - // FIXME: This is to handle a lot of hardcoded special cases where -1 is sent - // APITODO: Find and get rid of all hardcoded params in API Cmds and service layer - return -1L; - } - Long internalId = null; - // If annotation's empty, the cmd existed before 3.x try conversion to long - boolean isPre3x = annotation.since().isEmpty(); - // Match against Java's UUID regex to check if input is uuid string - boolean isUuid = uuid.matches("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"); - // Enforce that it's uuid for newly added apis from version 3.x - if (!isPre3x && !isUuid) - return null; - // Allow both uuid and internal id for pre3x apis - if (isPre3x && !isUuid) { - try { - internalId = Long.parseLong(uuid); - } catch (NumberFormatException e) { - internalId = null; - } - if (internalId != null) - return internalId; - } - // There may be multiple entities defined on the @EntityReference of a Response.class - // UUID CommandType would expect only one entityType, so use the first entityType - Class[] entities = annotation.entityType()[0].getAnnotation(EntityReference.class).value(); - // Go through each entity which is an interface to a VO class and get a VO object - // Try to getId() for the object using reflection, break on first non-null value - for (Class entity : entities) { - // For backward compatibility, we search within removed entities and let service layer deal - // with removed ones, return empty response or error - Object objVO = s_instance._entityMgr.findByUuidIncludingRemoved(entity, uuid); - if (objVO == null) { - continue; - } - // Invoke the getId method, get the internal long ID - // If that fails hide exceptions as the uuid may not exist - try { - internalId = ((InternalIdentity)objVO).getId(); - } catch (IllegalArgumentException e) { - } catch (NullPointerException e) { - } - // Return on first non-null Id for the uuid entity - if (internalId != null) - break; - } - if (internalId == null) { - if (s_logger.isDebugEnabled()) - s_logger.debug("Object entity uuid = " + uuid + " does not exist in the database."); - throw new InvalidParameterValueException("Invalid parameter " + annotation.name() + " value=" + uuid + - " due to incorrect long value format, or entity does not exist or due to incorrect parameter annotation for the field in api cmd class."); - } - return internalId; - } - - @SuppressWarnings({"unchecked", "rawtypes"}) - private static void setFieldValue(Field field, BaseCmd cmdObj, Object paramObj, Parameter annotation) throws IllegalArgumentException, ParseException { - try { - field.setAccessible(true); - CommandType fieldType = annotation.type(); - switch (fieldType) { - case BOOLEAN: - field.set(cmdObj, Boolean.valueOf(paramObj.toString())); - break; - case DATE: - // This piece of code is for maintaining backward compatibility - // and support both the date formats(Bug 9724) - // Do the date messaging for ListEventsCmd only - if (cmdObj instanceof ListEventsCmd || cmdObj instanceof DeleteEventsCmd || cmdObj instanceof ArchiveEventsCmd || - cmdObj instanceof ArchiveAlertsCmd || cmdObj instanceof DeleteAlertsCmd) { - boolean isObjInNewDateFormat = isObjInNewDateFormat(paramObj.toString()); - if (isObjInNewDateFormat) { - DateFormat newFormat = BaseCmd.NEW_INPUT_FORMAT; - synchronized (newFormat) { - field.set(cmdObj, newFormat.parse(paramObj.toString())); - } - } else { - DateFormat format = BaseCmd.INPUT_FORMAT; - synchronized (format) { - Date date = format.parse(paramObj.toString()); - if (field.getName().equals("startDate")) { - date = messageDate(date, 0, 0, 0); - } else if (field.getName().equals("endDate")) { - date = messageDate(date, 23, 59, 59); - } - field.set(cmdObj, date); - } - } - } else { - DateFormat format = BaseCmd.INPUT_FORMAT; - synchronized (format) { - format.setLenient(false); - field.set(cmdObj, format.parse(paramObj.toString())); - } - } - break; - case FLOAT: - // Assuming that the parameters have been checked for required before now, - // we ignore blank or null values and defer to the command to set a default - // value for optional parameters ... - if (paramObj != null && isNotBlank(paramObj.toString())) { - field.set(cmdObj, Float.valueOf(paramObj.toString())); - } - break; - case INTEGER: - // Assuming that the parameters have been checked for required before now, - // we ignore blank or null values and defer to the command to set a default - // value for optional parameters ... - if (paramObj != null && isNotBlank(paramObj.toString())) { - field.set(cmdObj, Integer.valueOf(paramObj.toString())); - } - break; - case LIST: - List listParam = new ArrayList(); - StringTokenizer st = new StringTokenizer(paramObj.toString(), ","); - while (st.hasMoreTokens()) { - String token = st.nextToken(); - CommandType listType = annotation.collectionType(); - switch (listType) { - case INTEGER: - listParam.add(Integer.valueOf(token)); - break; - case UUID: - if (token.isEmpty()) - break; - Long internalId = translateUuidToInternalId(token, annotation); - listParam.add(internalId); - break; - case LONG: { - listParam.add(Long.valueOf(token)); - } - break; - case SHORT: - listParam.add(Short.valueOf(token)); - case STRING: - listParam.add(token); - break; - } - } - field.set(cmdObj, listParam); - break; - case UUID: - if (paramObj.toString().isEmpty()) - break; - Long internalId = translateUuidToInternalId(paramObj.toString(), annotation); - field.set(cmdObj, internalId); - break; - case LONG: - field.set(cmdObj, Long.valueOf(paramObj.toString())); - break; - case SHORT: - field.set(cmdObj, Short.valueOf(paramObj.toString())); - break; - case STRING: - if ((paramObj != null) && paramObj.toString().length() > annotation.length()) { - s_logger.error("Value greater than max allowed length " + annotation.length() + " for param: " + field.getName()); - throw new InvalidParameterValueException("Value greater than max allowed length " + annotation.length() + " for param: " + field.getName()); - } - field.set(cmdObj, paramObj.toString()); - break; - case TZDATE: - field.set(cmdObj, DateUtil.parseTZDateString(paramObj.toString())); - break; - case MAP: - default: - field.set(cmdObj, paramObj); - break; - } - } catch (IllegalAccessException ex) { - s_logger.error("Error initializing command " + cmdObj.getCommandName() + ", field " + field.getName() + " is not accessible."); - throw new CloudRuntimeException("Internal error initializing parameters for command " + cmdObj.getCommandName() + " [field " + field.getName() + - " is not accessible]"); - } - } - - private static boolean isObjInNewDateFormat(String string) { - Matcher matcher = BaseCmd.newInputDateFormat.matcher(string); - return matcher.matches(); - } - - private static Date messageDate(Date date, int hourOfDay, int minute, int second) { - Calendar cal = Calendar.getInstance(); - cal.setTime(date); - cal.set(Calendar.HOUR_OF_DAY, hourOfDay); - cal.set(Calendar.MINUTE, minute); - cal.set(Calendar.SECOND, second); - return cal.getTime(); - } - - public static void plugService(Field field, BaseCmd cmd) { - - Class fc = field.getType(); - Object instance = null; - - if (instance == null) { - throw new CloudRuntimeException("Unable to plug service " + fc.getSimpleName() + " in command " + cmd.getClass().getSimpleName()); - } - - try { - field.setAccessible(true); - field.set(cmd, instance); - } catch (IllegalArgumentException e) { - s_logger.error("IllegalArgumentException at plugService for command " + cmd.getCommandName() + ", field " + field.getName()); - throw new CloudRuntimeException("Internal error at plugService for command " + cmd.getCommandName() + " [Illegal argumet at field " + field.getName() + "]"); - } catch (IllegalAccessException e) { - s_logger.error("Error at plugService for command " + cmd.getCommandName() + ", field " + field.getName() + " is not accessible."); - throw new CloudRuntimeException("Internal error at plugService for command " + cmd.getCommandName() + " [field " + field.getName() + " is not accessible]"); - } - } } diff --git a/server/src/com/cloud/api/ApiServer.java b/server/src/com/cloud/api/ApiServer.java index 7e29324a23b..c94bc97fd74 100755 --- a/server/src/com/cloud/api/ApiServer.java +++ b/server/src/com/cloud/api/ApiServer.java @@ -86,6 +86,7 @@ import org.springframework.stereotype.Component; import org.apache.cloudstack.acl.APIChecker; import org.apache.cloudstack.api.APICommand; +import org.apache.cloudstack.api.ApiConstants; import org.apache.cloudstack.api.ApiErrorCode; import org.apache.cloudstack.api.BaseAsyncCmd; import org.apache.cloudstack.api.BaseAsyncCreateCmd; @@ -122,6 +123,8 @@ import org.apache.cloudstack.framework.jobs.AsyncJobManager; import org.apache.cloudstack.framework.jobs.impl.AsyncJobVO; import org.apache.cloudstack.managed.context.ManagedContextRunnable; +import com.cloud.api.dispatch.DispatchChainFactory; +import com.cloud.api.dispatch.DispatchTask; import com.cloud.api.response.ApiResponseSerializer; import com.cloud.configuration.Config; import com.cloud.domain.Domain; @@ -156,14 +159,22 @@ import com.cloud.utils.exception.ExceptionProxyObject; @Component public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiServerService { + private static final String UTF_8 = "UTF-8"; private static final Logger s_logger = Logger.getLogger(ApiServer.class.getName()); private static final Logger s_accessLogger = Logger.getLogger("apiserver." + ApiServer.class.getName()); - private static boolean encodeApiResponse = false; - private static String jsonContentType = "text/javascript"; - private static String controlCharacters = "[\000-\011\013-\014\016-\037\177]"; // Non-printable ASCII characters - numbers 0 to 31 and 127 decimal - @Inject ApiDispatcher _dispatcher; + public static boolean encodeApiResponse = false; + public static String jsonContentType = "text/javascript"; + /** + * Non-printable ASCII characters - numbers 0 to 31 and 127 decimal + */ + public static final String CONTROL_CHARACTERS = "[\000-\011\013-\014\016-\037\177]"; + + @Inject + protected ApiDispatcher _dispatcher; + @Inject + protected DispatchChainFactory dispatchChainFactory; @Inject private AccountManager _accountMgr; @Inject @@ -191,27 +202,27 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } @Override - public boolean configure(String name, Map params) throws ConfigurationException { + public boolean configure(final String name, final Map params) throws ConfigurationException { return true; } @Override public boolean start() { Integer apiPort = null; // api port, null by default - SearchCriteria sc = _configDao.createSearchCriteria(); + final SearchCriteria sc = _configDao.createSearchCriteria(); sc.addAnd("name", SearchCriteria.Op.EQ, Config.IntegrationAPIPort.key()); - List values = _configDao.search(sc, null); + final List values = _configDao.search(sc, null); if ((values != null) && (values.size() > 0)) { - ConfigurationVO apiPortConfig = values.get(0); + final ConfigurationVO apiPortConfig = values.get(0); if (apiPortConfig.getValue() != null) { apiPort = Integer.parseInt(apiPortConfig.getValue()); } } - Map configs = _configDao.getConfiguration(); - String strSnapshotLimit = configs.get(Config.ConcurrentSnapshotsThresholdPerHost.key()); + final Map configs = _configDao.getConfiguration(); + final String strSnapshotLimit = configs.get(Config.ConcurrentSnapshotsThresholdPerHost.key()); if (strSnapshotLimit != null) { - Long snapshotLimit = NumbersUtil.parseLong(strSnapshotLimit, 1L); + final Long snapshotLimit = NumbersUtil.parseLong(strSnapshotLimit, 1L); if (snapshotLimit.longValue() <= 0) { s_logger.debug("Global config parameter " + Config.ConcurrentSnapshotsThresholdPerHost.toString() + " is less or equal 0; defaulting to unlimited"); } else { @@ -219,20 +230,20 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } } - Set> cmdClasses = new HashSet>(); - for (PluggableService pluggableService : _pluggableServices) { + final Set> cmdClasses = new HashSet>(); + for (final PluggableService pluggableService : _pluggableServices) { cmdClasses.addAll(pluggableService.getCommands()); if (s_logger.isDebugEnabled()) { s_logger.debug("Discovered plugin " + pluggableService.getClass().getSimpleName()); } } - for (Class cmdClass : cmdClasses) { - APICommand at = cmdClass.getAnnotation(APICommand.class); + for (final Class cmdClass : cmdClasses) { + final APICommand at = cmdClass.getAnnotation(APICommand.class); if (at == null) { throw new CloudRuntimeException(String.format("%s is claimed as a API command, but it doesn't have @APICommand annotation", cmdClass.getName())); } - String apiName = at.name(); + final String apiName = at.name(); if (s_apiNameCmdClassMap.containsKey(apiName)) { s_logger.error("API Cmd class " + cmdClass.getName() + " has non-unique apiname" + apiName); continue; @@ -241,13 +252,13 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } setEncodeApiResponse(Boolean.valueOf(_configDao.getValue(Config.EncodeApiResponse.key()))); - String jsonType = _configDao.getValue(Config.JavaScriptDefaultContentType.key()); + final String jsonType = _configDao.getValue(Config.JavaScriptDefaultContentType.key()); if (jsonType != null) { jsonContentType = jsonType; } if (apiPort != null) { - ListenerThread listenerThread = new ListenerThread(this, apiPort); + final ListenerThread listenerThread = new ListenerThread(this, apiPort); listenerThread.start(); } @@ -258,13 +269,13 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer // If integration api port is not configured, actual OTW requests will be received by ApiServlet @SuppressWarnings({"unchecked", "rawtypes"}) @Override - public void handle(HttpRequest request, HttpResponse response, HttpContext context) throws HttpException, IOException { + public void handle(final HttpRequest request, final HttpResponse response, final HttpContext context) throws HttpException, IOException { // Create StringBuffer to log information in access log - StringBuffer sb = new StringBuffer(); - HttpServerConnection connObj = (HttpServerConnection)context.getAttribute("http.connection"); + final StringBuffer sb = new StringBuffer(); + final HttpServerConnection connObj = (HttpServerConnection)context.getAttribute("http.connection"); if (connObj instanceof SocketHttpServerConnection) { - InetAddress remoteAddr = ((SocketHttpServerConnection)connObj).getRemoteAddress(); + final InetAddress remoteAddr = ((SocketHttpServerConnection)connObj).getRemoteAddress(); sb.append(remoteAddr.toString() + " -- "); } sb.append(StringUtils.cleanString(request.getRequestLine().toString())); @@ -272,8 +283,8 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer try { List paramList = null; try { - paramList = URLEncodedUtils.parse(new URI(request.getRequestLine().getUri()), "UTF-8"); - } catch (URISyntaxException e) { + paramList = URLEncodedUtils.parse(new URI(request.getRequestLine().getUri()), UTF_8); + } catch (final URISyntaxException e) { s_logger.error("Error parsing url request", e); } @@ -282,9 +293,9 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer // APITODO: Use Guava's (import com.google.common.collect.Multimap;) // (Immutable)Multimap paramMultiMap = HashMultimap.create(); // Map> parameterMap = paramMultiMap.asMap(); - Map parameterMap = new HashMap(); + final Map parameterMap = new HashMap(); String responseType = BaseCmd.RESPONSE_TYPE_XML; - for (NameValuePair param : paramList) { + for (final NameValuePair param : paramList) { if (param.getName().equalsIgnoreCase("response")) { responseType = param.getValue(); continue; @@ -304,15 +315,15 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer // always trust commands from API port, user context will always be UID_SYSTEM/ACCOUNT_ID_SYSTEM CallContext.register(_accountMgr.getSystemUser(), _accountMgr.getSystemAccount()); sb.insert(0, "(userId=" + User.UID_SYSTEM + " accountId=" + Account.ACCOUNT_ID_SYSTEM + " sessionId=" + null + ") "); - String responseText = handleRequest(parameterMap, responseType, sb); + final String responseText = handleRequest(parameterMap, responseType, sb); sb.append(" 200 " + ((responseText == null) ? 0 : responseText.length())); writeResponse(response, responseText, HttpStatus.SC_OK, responseType, null); - } catch (ServerApiException se) { - String responseText = getSerializedApiError(se, parameterMap, responseType); + } catch (final ServerApiException se) { + final String responseText = getSerializedApiError(se, parameterMap, responseType); writeResponse(response, responseText, se.getErrorCode().getHttpCode(), responseType, se.getDescription()); sb.append(" " + se.getErrorCode() + " " + se.getDescription()); - } catch (RuntimeException e) { + } catch (final RuntimeException e) { // log runtime exception like NullPointerException to help identify the source easier s_logger.error("Unhandled exception, ", e); throw e; @@ -323,9 +334,32 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } } + @SuppressWarnings({"unchecked", "rawtypes"}) + public void checkCharacterInkParams(final Map params) { + final Map stringMap = new HashMap(); + final Set keys = params.keySet(); + final Iterator keysIter = keys.iterator(); + while (keysIter.hasNext()) { + final String key = (String)keysIter.next(); + final String[] value = (String[])params.get(key); + // fail if parameter value contains ASCII control (non-printable) characters + if (value[0] != null) { + final Pattern pattern = Pattern.compile(CONTROL_CHARACTERS); + final Matcher matcher = pattern.matcher(value[0]); + if (matcher.find()) { + throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Received value " + value[0] + " for parameter " + key + + " is invalid, contains illegal ASCII non-printable characters"); + } + } + stringMap.put(key, value[0]); + } + } + @Override @SuppressWarnings("rawtypes") - public String handleRequest(Map params, String responseType, StringBuffer auditTrailSb) throws ServerApiException { + public String handleRequest(final Map params, final String responseType, final StringBuffer auditTrailSb) throws ServerApiException { + checkCharacterInkParams(params); + String response = null; String[] command = null; @@ -335,37 +369,27 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer s_logger.error("invalid request, no command sent"); if (s_logger.isTraceEnabled()) { s_logger.trace("dumping request parameters"); - for (Object key : params.keySet()) { - String keyStr = (String)key; - String[] value = (String[])params.get(key); + for (final Object key : params.keySet()) { + final String keyStr = (String)key; + final String[] value = (String[])params.get(key); s_logger.trace(" key: " + keyStr + ", value: " + ((value == null) ? "'null'" : value[0])); } } throw new ServerApiException(ApiErrorCode.UNSUPPORTED_ACTION_ERROR, "Invalid request, no command sent"); } else { - Map paramMap = new HashMap(); - Set keys = params.keySet(); - Iterator keysIter = keys.iterator(); + final Map paramMap = new HashMap(); + final Set keys = params.keySet(); + final Iterator keysIter = keys.iterator(); while (keysIter.hasNext()) { - String key = (String)keysIter.next(); + final String key = (String)keysIter.next(); if ("command".equalsIgnoreCase(key)) { continue; } - String[] value = (String[])params.get(key); - // fail if parameter value contains ASCII control (non-printable) characters - if (value[0] != null) { - Pattern pattern = Pattern.compile(controlCharacters); - Matcher matcher = pattern.matcher(value[0]); - if (matcher.find()) { - throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Received value " + value[0] + " for parameter " + key + - " is invalid, contains illegal ASCII non-printable characters"); - } - } + final String[] value = (String[])params.get(key); paramMap.put(key, value[0]); } Class cmdClass = getCmdClass(command[0]); - if (cmdClass != null) { APICommand annotation = cmdClass.getAnnotation(APICommand.class); if (annotation == null) { @@ -378,7 +402,7 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer cmdObj.configure(); cmdObj.setFullUrlParams(paramMap); cmdObj.setResponseType(responseType); - cmdObj.setHttpMethod(paramMap.get("httpmethod").toString()); + cmdObj.setHttpMethod(paramMap.get(ApiConstants.HTTPMETHOD).toString()); // This is where the command is either serialized, or directly dispatched response = queueCommand(cmdObj, paramMap); @@ -391,24 +415,24 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer buildAuditTrail(auditTrailSb, command[0], response); } else { if (!command[0].equalsIgnoreCase("login") && !command[0].equalsIgnoreCase("logout")) { - String errorString = "Unknown API command: " + command[0]; + final String errorString = "Unknown API command: " + command[0]; s_logger.warn(errorString); auditTrailSb.append(" " + errorString); throw new ServerApiException(ApiErrorCode.UNSUPPORTED_ACTION_ERROR, errorString); } } } - } catch (InvalidParameterValueException ex) { + } catch (final InvalidParameterValueException ex) { s_logger.info(ex.getMessage()); throw new ServerApiException(ApiErrorCode.PARAM_ERROR, ex.getMessage(), ex); - } catch (IllegalArgumentException ex) { + } catch (final IllegalArgumentException ex) { s_logger.info(ex.getMessage()); throw new ServerApiException(ApiErrorCode.PARAM_ERROR, ex.getMessage(), ex); - } catch (PermissionDeniedException ex) { - ArrayList idList = ex.getIdProxyList(); + } catch (final PermissionDeniedException ex) { + final ArrayList idList = ex.getIdProxyList(); if (idList != null) { - StringBuffer buf = new StringBuffer(); - for (ExceptionProxyObject obj : idList) { + final StringBuffer buf = new StringBuffer(); + for (final ExceptionProxyObject obj : idList) { buf.append(obj.getDescription()); buf.append(":"); buf.append(obj.getUuid()); @@ -419,10 +443,10 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer s_logger.info("PermissionDenied: " + ex.getMessage()); } throw new ServerApiException(ApiErrorCode.ACCOUNT_ERROR, ex.getMessage(), ex); - } catch (AccountLimitException ex) { + } catch (final AccountLimitException ex) { s_logger.info(ex.getMessage()); throw new ServerApiException(ApiErrorCode.ACCOUNT_RESOURCE_LIMIT_ERROR, ex.getMessage(), ex); - } catch (InsufficientCapacityException ex) { + } catch (final InsufficientCapacityException ex) { s_logger.info(ex.getMessage()); String errorMsg = ex.getMessage(); if (CallContext.current().getCallingAccount().getType() != Account.ACCOUNT_TYPE_ADMIN) { @@ -430,10 +454,10 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer errorMsg = BaseCmd.USER_ERROR_MESSAGE; } throw new ServerApiException(ApiErrorCode.INSUFFICIENT_CAPACITY_ERROR, errorMsg, ex); - } catch (ResourceAllocationException ex) { + } catch (final ResourceAllocationException ex) { s_logger.info(ex.getMessage()); throw new ServerApiException(ApiErrorCode.RESOURCE_ALLOCATION_ERROR, ex.getMessage(), ex); - } catch (ResourceUnavailableException ex) { + } catch (final ResourceUnavailableException ex) { s_logger.info(ex.getMessage()); String errorMsg = ex.getMessage(); if (CallContext.current().getCallingAccount().getType() != Account.ACCOUNT_TYPE_ADMIN) { @@ -441,11 +465,11 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer errorMsg = BaseCmd.USER_ERROR_MESSAGE; } throw new ServerApiException(ApiErrorCode.RESOURCE_UNAVAILABLE_ERROR, errorMsg, ex); - } catch (ServerApiException ex) { + } catch (final ServerApiException ex) { s_logger.info(ex.getDescription()); throw ex; - } catch (Exception ex) { - s_logger.error("unhandled exception executing api command: " + ((command == null) ? "null" : command[0]), ex); + } catch (final Exception ex) { + s_logger.error("unhandled exception executing api command: " + ((command == null) ? "null" : command), ex); String errorMsg = ex.getMessage(); if (CallContext.current().getCallingAccount().getType() != Account.ACCOUNT_TYPE_ADMIN) { // hide internal details to non-admin user for security reason @@ -457,28 +481,28 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer return response; } - private String getBaseAsyncResponse(long jobId, BaseAsyncCmd cmd) { - AsyncJobResponse response = new AsyncJobResponse(); + private String getBaseAsyncResponse(final long jobId, final BaseAsyncCmd cmd) { + final AsyncJobResponse response = new AsyncJobResponse(); - AsyncJob job = _entityMgr.findById(AsyncJob.class, jobId); + final AsyncJob job = _entityMgr.findById(AsyncJob.class, jobId); response.setJobId(job.getUuid()); response.setResponseName(cmd.getCommandName()); return ApiResponseSerializer.toSerializedString(response, cmd.getResponseType()); } - private String getBaseAsyncCreateResponse(long jobId, BaseAsyncCreateCmd cmd, String objectUuid) { - CreateCmdResponse response = new CreateCmdResponse(); - AsyncJob job = _entityMgr.findById(AsyncJob.class, jobId); + private String getBaseAsyncCreateResponse(final long jobId, final BaseAsyncCreateCmd cmd, final String objectUuid) { + final CreateCmdResponse response = new CreateCmdResponse(); + final AsyncJob job = _entityMgr.findById(AsyncJob.class, jobId); response.setJobId(job.getUuid()); response.setId(objectUuid); response.setResponseName(cmd.getCommandName()); return ApiResponseSerializer.toSerializedString(response, cmd.getResponseType()); } - private String queueCommand(BaseCmd cmdObj, Map params) throws Exception { - CallContext ctx = CallContext.current(); - Long callerUserId = ctx.getCallingUserId(); - Account caller = ctx.getCallingAccount(); + private String queueCommand(final BaseCmd cmdObj, final Map params) throws Exception { + final CallContext ctx = CallContext.current(); + final Long callerUserId = ctx.getCallingUserId(); + final Account caller = ctx.getCallingAccount(); // Queue command based on Cmd super class: // BaseCmd: cmd is dispatched to ApiDispatcher, executed, serialized and returned. @@ -488,16 +512,16 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer Long objectId = null; String objectUuid = null; if (cmdObj instanceof BaseAsyncCreateCmd) { - BaseAsyncCreateCmd createCmd = (BaseAsyncCreateCmd)cmdObj; + final BaseAsyncCreateCmd createCmd = (BaseAsyncCreateCmd)cmdObj; _dispatcher.dispatchCreateCmd(createCmd, params); objectId = createCmd.getEntityId(); objectUuid = createCmd.getEntityUuid(); params.put("id", objectId.toString()); } else { - ApiDispatcher.processParameters(cmdObj, params); + dispatchChainFactory.getStandardDispatchChain().dispatch(new DispatchTask(cmdObj, params)); } - BaseAsyncCmd asyncCmd = (BaseAsyncCmd)cmdObj; + final BaseAsyncCmd asyncCmd = (BaseAsyncCmd)cmdObj; if (callerUserId != null) { params.put("ctxUserId", callerUserId.toString()); @@ -510,7 +534,7 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer asyncCmd.setStartEventId(startEventId); // save the scheduled event - Long eventId = + final Long eventId = ActionEventUtils.onScheduledActionEvent((callerUserId == null) ? User.UID_SYSTEM : callerUserId, asyncCmd.getEntityOwnerId(), asyncCmd.getEventType(), asyncCmd.getEventDescription(), asyncCmd.isDisplayResourceEnabled(), startEventId); if (startEventId == 0) { @@ -527,16 +551,16 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer asyncCmd.getInstanceType() != null ? asyncCmd.getInstanceType().toString() : null); job.setDispatcher(_asyncDispatcher.getName()); - long jobId = _asyncMgr.submitAsyncJob(job); + final long jobId = _asyncMgr.submitAsyncJob(job); if (jobId == 0L) { - String errorMsg = "Unable to schedule async job for command " + job.getCmd(); + final String errorMsg = "Unable to schedule async job for command " + job.getCmd(); s_logger.warn(errorMsg); throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, errorMsg); } if (objectId != null) { - String objUuid = (objectUuid == null) ? objectId.toString() : objectUuid; + final String objUuid = (objectUuid == null) ? objectId.toString() : objectUuid; return getBaseAsyncCreateResponse(jobId, (BaseAsyncCreateCmd)asyncCmd, objUuid); } else { SerializationContext.current().setUuidTranslation(true); @@ -563,8 +587,8 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } @SuppressWarnings("unchecked") - private void buildAsyncListResponse(BaseListCmd command, Account account) { - List responses = ((ListResponse)command.getResponseObject()).getResponses(); + private void buildAsyncListResponse(final BaseListCmd command, final Account account) { + final List responses = ((ListResponse)command.getResponseObject()).getResponses(); if (responses != null && responses.size() > 0) { List jobs = null; @@ -579,18 +603,18 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer return; } - Map objectJobMap = new HashMap(); - for (AsyncJob job : jobs) { + final Map objectJobMap = new HashMap(); + for (final AsyncJob job : jobs) { if (job.getInstanceId() == null) { continue; } - String instanceUuid = ApiDBUtils.findJobInstanceUuid(job); + final String instanceUuid = ApiDBUtils.findJobInstanceUuid(job); objectJobMap.put(instanceUuid, job); } - for (ResponseObject response : responses) { + for (final ResponseObject response : responses) { if (response.getObjectId() != null && objectJobMap.containsKey(response.getObjectId())) { - AsyncJob job = objectJobMap.get(response.getObjectId()); + final AsyncJob job = objectJobMap.get(response.getObjectId()); response.setJobId(job.getUuid()); response.setJobStatus(job.getStatus().ordinal()); } @@ -598,7 +622,7 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } } - private void buildAuditTrail(StringBuffer auditTrailSb, String command, String result) { + private void buildAuditTrail(final StringBuffer auditTrailSb, final String command, final String result) { if (result == null) { return; } @@ -611,31 +635,31 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } @Override - public boolean verifyRequest(Map requestParameters, Long userId) throws ServerApiException { + public boolean verifyRequest(final Map requestParameters, final Long userId) throws ServerApiException { try { String apiKey = null; String secretKey = null; String signature = null; String unsignedRequest = null; - String[] command = (String[])requestParameters.get("command"); + final String[] command = (String[])requestParameters.get(ApiConstants.COMMAND); if (command == null) { s_logger.info("missing command, ignoring request..."); return false; } - String commandName = command[0]; + final String commandName = command[0]; // if userId not null, that mean that user is logged in if (userId != null) { - User user = ApiDBUtils.findUserById(userId); + final User user = ApiDBUtils.findUserById(userId); try { checkCommandAvailable(user, commandName); - } catch (RequestLimitException ex) { + } catch (final RequestLimitException ex) { s_logger.debug(ex.getMessage()); throw new ServerApiException(ApiErrorCode.API_LIMIT_EXCEED, ex.getMessage()); - } catch (PermissionDeniedException ex) { + } catch (final PermissionDeniedException ex) { s_logger.debug("The given command:" + commandName + " does not exist or it is not available for user with id:" + userId); throw new ServerApiException(ApiErrorCode.UNSUPPORTED_ACTION_ERROR, "The given command does not exist or it is not available for user"); } @@ -650,9 +674,9 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer // - build a request string with sorted params, make sure it's all lowercase // - sign the request, verify the signature is the same - List parameterNames = new ArrayList(); + final List parameterNames = new ArrayList(); - for (Object paramNameObj : requestParameters.keySet()) { + for (final Object paramNameObj : requestParameters.keySet()) { parameterNames.add((String)paramNameObj); // put the name in a list that we'll sort later } @@ -661,25 +685,25 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer String signatureVersion = null; String expires = null; - for (String paramName : parameterNames) { + for (final String paramName : parameterNames) { // parameters come as name/value pairs in the form String/String[] - String paramValue = ((String[])requestParameters.get(paramName))[0]; + final String paramValue = ((String[])requestParameters.get(paramName))[0]; - if ("signature".equalsIgnoreCase(paramName)) { + if (ApiConstants.SIGNATURE.equalsIgnoreCase(paramName)) { signature = paramValue; } else { - if ("apikey".equalsIgnoreCase(paramName)) { + if (ApiConstants.API_KEY.equalsIgnoreCase(paramName)) { apiKey = paramValue; - } else if ("signatureversion".equalsIgnoreCase(paramName)) { + } else if (ApiConstants.SIGNATURE_VERSION.equalsIgnoreCase(paramName)) { signatureVersion = paramValue; - } else if ("expires".equalsIgnoreCase(paramName)) { + } else if (ApiConstants.EXPIRES.equalsIgnoreCase(paramName)) { expires = paramValue; } if (unsignedRequest == null) { - unsignedRequest = paramName + "=" + URLEncoder.encode(paramValue, "UTF-8").replaceAll("\\+", "%20"); + unsignedRequest = paramName + "=" + URLEncoder.encode(paramValue, UTF_8).replaceAll("\\+", "%20"); } else { - unsignedRequest = unsignedRequest + "&" + paramName + "=" + URLEncoder.encode(paramValue, "UTF-8").replaceAll("\\+", "%20"); + unsignedRequest = unsignedRequest + "&" + paramName + "=" + URLEncoder.encode(paramValue, UTF_8).replaceAll("\\+", "%20"); } } } @@ -701,30 +725,30 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer synchronized (DateFormatToUse) { try { expiresTS = DateFormatToUse.parse(expires); - } catch (ParseException pe) { + } catch (final ParseException pe) { s_logger.debug("Incorrect date format for Expires parameter", pe); return false; } } - Date now = new Date(System.currentTimeMillis()); + final Date now = new Date(System.currentTimeMillis()); if (expiresTS.before(now)) { s_logger.debug("Request expired -- ignoring ...sig: " + signature + ", apiKey: " + apiKey); return false; } } - TransactionLegacy txn = TransactionLegacy.open(TransactionLegacy.CLOUD_DB); + final TransactionLegacy txn = TransactionLegacy.open(TransactionLegacy.CLOUD_DB); txn.close(); User user = null; // verify there is a user with this api key - Pair userAcctPair = _accountMgr.findUserByApiKey(apiKey); + final Pair userAcctPair = _accountMgr.findUserByApiKey(apiKey); if (userAcctPair == null) { s_logger.debug("apiKey does not map to a valid user -- ignoring request, apiKey: " + apiKey); return false; } user = userAcctPair.first(); - Account account = userAcctPair.second(); + final Account account = userAcctPair.second(); if (user.getState() != Account.State.enabled || !account.getState().equals(Account.State.enabled)) { s_logger.info("disabled or locked user accessing the api, userid = " + user.getId() + "; name = " + user.getUsername() + "; state: " + user.getState() + @@ -734,10 +758,10 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer try { checkCommandAvailable(user, commandName); - } catch (RequestLimitException ex) { + } catch (final RequestLimitException ex) { s_logger.debug(ex.getMessage()); throw new ServerApiException(ApiErrorCode.API_LIMIT_EXCEED, ex.getMessage()); - } catch (PermissionDeniedException ex) { + } catch (final PermissionDeniedException ex) { s_logger.debug("The given command:" + commandName + " does not exist or it is not available for user"); throw new ServerApiException(ApiErrorCode.UNSUPPORTED_ACTION_ERROR, "The given command:" + commandName + " does not exist or it is not available for user with id:" + userId); @@ -752,30 +776,30 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer unsignedRequest = unsignedRequest.toLowerCase(); - Mac mac = Mac.getInstance("HmacSHA1"); - SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(), "HmacSHA1"); + final Mac mac = Mac.getInstance("HmacSHA1"); + final SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(), "HmacSHA1"); mac.init(keySpec); mac.update(unsignedRequest.getBytes()); - byte[] encryptedBytes = mac.doFinal(); - String computedSignature = Base64.encodeBase64String(encryptedBytes); - boolean equalSig = signature.equals(computedSignature); + final byte[] encryptedBytes = mac.doFinal(); + final String computedSignature = Base64.encodeBase64String(encryptedBytes); + final boolean equalSig = signature.equals(computedSignature); if (!equalSig) { s_logger.info("User signature: " + signature + " is not equaled to computed signature: " + computedSignature); } else { CallContext.register(user, account); } return equalSig; - } catch (ServerApiException ex) { + } catch (final ServerApiException ex) { throw ex; - } catch (Exception ex) { + } catch (final Exception ex) { s_logger.error("unable to verify request signature"); } return false; } @Override - public Long fetchDomainId(String domainUUID) { - Domain domain = _domainMgr.getDomain(domainUUID); + public Long fetchDomainId(final String domainUUID) { + final Domain domain = _domainMgr.getDomain(domainUUID); if (domain != null) return domain.getId(); else @@ -783,15 +807,15 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } @Override - public void loginUser(HttpSession session, String username, String password, Long domainId, String domainPath, String loginIpAddress, - Map requestParameters) throws CloudAuthenticationException { + public void loginUser(final HttpSession session, final String username, final String password, Long domainId, final String domainPath, final String loginIpAddress, + final Map requestParameters) throws CloudAuthenticationException { // We will always use domainId first. If that does not exist, we will use domain name. If THAT doesn't exist // we will default to ROOT if (domainId == null) { if (domainPath == null || domainPath.trim().length() == 0) { domainId = Domain.ROOT_DOMAIN; } else { - Domain domainObj = _domainMgr.findDomainByPath(domainPath); + final Domain domainObj = _domainMgr.findDomainByPath(domainPath); if (domainObj != null) { domainId = domainObj.getId(); } else { // if an unknown path is passed in, fail the login call @@ -800,26 +824,26 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } } - UserAccount userAcct = _accountMgr.authenticateUser(username, password, domainId, loginIpAddress, requestParameters); + final UserAccount userAcct = _accountMgr.authenticateUser(username, password, domainId, loginIpAddress, requestParameters); if (userAcct != null) { - String timezone = userAcct.getTimezone(); + final String timezone = userAcct.getTimezone(); float offsetInHrs = 0f; if (timezone != null) { - TimeZone t = TimeZone.getTimeZone(timezone); + final TimeZone t = TimeZone.getTimeZone(timezone); s_logger.info("Current user logged in under " + timezone + " timezone"); - java.util.Date date = new java.util.Date(); - long longDate = date.getTime(); - float offsetInMs = (t.getOffset(longDate)); + final java.util.Date date = new java.util.Date(); + final long longDate = date.getTime(); + final float offsetInMs = (t.getOffset(longDate)); offsetInHrs = offsetInMs / (1000 * 60 * 60); s_logger.info("Timezone offset from UTC is: " + offsetInHrs); } - Account account = _accountMgr.getAccount(userAcct.getAccountId()); + final Account account = _accountMgr.getAccount(userAcct.getAccountId()); // set the userId and account object for everyone session.setAttribute("userid", userAcct.getId()); - UserVO user = (UserVO)_accountMgr.getActiveUser(userAcct.getId()); + final UserVO user = (UserVO)_accountMgr.getActiveUser(userAcct.getId()); if (user.getUuid() != null) { session.setAttribute("user_UUID", user.getUuid()); } @@ -831,7 +855,7 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer session.setAttribute("account", account.getAccountName()); session.setAttribute("domainid", account.getDomainId()); - DomainVO domain = (DomainVO)_domainMgr.getDomain(account.getDomainId()); + final DomainVO domain = (DomainVO)_domainMgr.getDomain(account.getDomainId()); if (domain.getUuid() != null) { session.setAttribute("domain_UUID", domain.getUuid()); } @@ -847,10 +871,10 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer // (bug 5483) generate a session key that the user must submit on every request to prevent CSRF, add that // to the login response so that session-based authenticators know to send the key back - SecureRandom sesssionKeyRandom = new SecureRandom(); - byte sessionKeyBytes[] = new byte[20]; + final SecureRandom sesssionKeyRandom = new SecureRandom(); + final byte sessionKeyBytes[] = new byte[20]; sesssionKeyRandom.nextBytes(sessionKeyBytes); - String sessionKey = Base64.encodeBase64String(sessionKeyBytes); + final String sessionKey = Base64.encodeBase64String(sessionKeyBytes); session.setAttribute("sessionkey", sessionKey); return; @@ -859,14 +883,14 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } @Override - public void logoutUser(long userId) { + public void logoutUser(final long userId) { _accountMgr.logoutUser(userId); return; } @Override - public boolean verifyUser(Long userId) { - User user = _accountMgr.getUserIncludingRemoved(userId); + public boolean verifyUser(final Long userId) { + final User user = _accountMgr.getUserIncludingRemoved(userId); Account account = null; if (user != null) { account = _accountMgr.getAccount(user.getAccountId()); @@ -880,46 +904,46 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer return true; } - private void checkCommandAvailable(User user, String commandName) throws PermissionDeniedException { + private void checkCommandAvailable(final User user, final String commandName) throws PermissionDeniedException { if (user == null) { throw new PermissionDeniedException("User is null for role based API access check for command" + commandName); } - for (APIChecker apiChecker : _apiAccessCheckers) { + for (final APIChecker apiChecker : _apiAccessCheckers) { apiChecker.checkAccess(user, commandName); } } @Override - public Class getCmdClass(String cmdName) { + public Class getCmdClass(final String cmdName) { return s_apiNameCmdClassMap.get(cmdName); } // FIXME: rather than isError, we might was to pass in the status code to give more flexibility - private void writeResponse(HttpResponse resp, final String responseText, final int statusCode, String responseType, String reasonPhrase) { + private void writeResponse(final HttpResponse resp, final String responseText, final int statusCode, final String responseType, final String reasonPhrase) { try { resp.setStatusCode(statusCode); resp.setReasonPhrase(reasonPhrase); - BasicHttpEntity body = new BasicHttpEntity(); + final BasicHttpEntity body = new BasicHttpEntity(); if (BaseCmd.RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) { // JSON response body.setContentType(jsonContentType); if (responseText == null) { - body.setContent(new ByteArrayInputStream("{ \"error\" : { \"description\" : \"Internal Server Error\" } }".getBytes("UTF-8"))); + body.setContent(new ByteArrayInputStream("{ \"error\" : { \"description\" : \"Internal Server Error\" } }".getBytes(UTF_8))); } } else { body.setContentType("text/xml"); if (responseText == null) { - body.setContent(new ByteArrayInputStream("Internal Server Error".getBytes("UTF-8"))); + body.setContent(new ByteArrayInputStream("Internal Server Error".getBytes(UTF_8))); } } if (responseText != null) { - body.setContent(new ByteArrayInputStream(responseText.getBytes("UTF-8"))); + body.setContent(new ByteArrayInputStream(responseText.getBytes(UTF_8))); } resp.setEntity(body); - } catch (Exception ex) { + } catch (final Exception ex) { s_logger.error("error!", ex); } } @@ -934,10 +958,10 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer private ServerSocket _serverSocket = null; private HttpParams _params = null; - public ListenerThread(ApiServer requestHandler, int port) { + public ListenerThread(final ApiServer requestHandler, final int port) { try { _serverSocket = new ServerSocket(port); - } catch (IOException ioex) { + } catch (final IOException ioex) { s_logger.error("error initializing api server", ioex); return; } @@ -950,14 +974,14 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer .setParameter(CoreProtocolPNames.ORIGIN_SERVER, "HttpComponents/1.1"); // Set up the HTTP protocol processor - BasicHttpProcessor httpproc = new BasicHttpProcessor(); + final BasicHttpProcessor httpproc = new BasicHttpProcessor(); httpproc.addInterceptor(new ResponseDate()); httpproc.addInterceptor(new ResponseServer()); httpproc.addInterceptor(new ResponseContent()); httpproc.addInterceptor(new ResponseConnControl()); // Set up request handlers - HttpRequestHandlerRegistry reqistry = new HttpRequestHandlerRegistry(); + final HttpRequestHandlerRegistry reqistry = new HttpRequestHandlerRegistry(); reqistry.register("*", requestHandler); // Set up the HTTP service @@ -972,15 +996,15 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer while (!Thread.interrupted()) { try { // Set up HTTP connection - Socket socket = _serverSocket.accept(); - DefaultHttpServerConnection conn = new DefaultHttpServerConnection(); + final Socket socket = _serverSocket.accept(); + final DefaultHttpServerConnection conn = new DefaultHttpServerConnection(); conn.bind(socket, _params); // Execute a new worker task to handle the request s_executor.execute(new WorkerTask(_httpService, conn, s_workerCount++)); - } catch (InterruptedIOException ex) { + } catch (final InterruptedIOException ex) { break; - } catch (IOException e) { + } catch (final IOException e) { s_logger.error("I/O error initializing connection thread", e); break; } @@ -999,33 +1023,33 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer @Override protected void runInContext() { - HttpContext context = new BasicHttpContext(null); + final HttpContext context = new BasicHttpContext(null); try { while (!Thread.interrupted() && _conn.isOpen()) { _httpService.handleRequest(_conn, context); _conn.close(); } - } catch (ConnectionClosedException ex) { + } catch (final ConnectionClosedException ex) { if (s_logger.isTraceEnabled()) { s_logger.trace("ApiServer: Client closed connection"); } - } catch (IOException ex) { + } catch (final IOException ex) { if (s_logger.isTraceEnabled()) { s_logger.trace("ApiServer: IOException - " + ex); } - } catch (HttpException ex) { + } catch (final HttpException ex) { s_logger.warn("ApiServer: Unrecoverable HTTP protocol violation" + ex); } finally { try { _conn.shutdown(); - } catch (IOException ignore) { + } catch (final IOException ignore) { } } } } @Override - public String getSerializedApiError(int errorCode, String errorText, Map apiCommandParams, String responseType) { + public String getSerializedApiError(final int errorCode, final String errorText, final Map apiCommandParams, final String responseType) { String responseName = null; Class cmdClass = null; String responseText = null; @@ -1034,10 +1058,10 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer if (apiCommandParams == null || apiCommandParams.isEmpty()) { responseName = "errorresponse"; } else { - Object cmdObj = apiCommandParams.get("command"); + final Object cmdObj = apiCommandParams.get(ApiConstants.COMMAND); // cmd name can be null when "command" parameter is missing in the request if (cmdObj != null) { - String cmdName = ((String[])cmdObj)[0]; + final String cmdName = ((String[])cmdObj)[0]; cmdClass = getCmdClass(cmdName); if (cmdClass != null) { responseName = ((BaseCmd)cmdClass.newInstance()).getCommandName(); @@ -1046,21 +1070,21 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } } } - ExceptionResponse apiResponse = new ExceptionResponse(); + final ExceptionResponse apiResponse = new ExceptionResponse(); apiResponse.setErrorCode(errorCode); apiResponse.setErrorText(errorText); apiResponse.setResponseName(responseName); SerializationContext.current().setUuidTranslation(true); responseText = ApiResponseSerializer.toSerializedString(apiResponse, responseType); - } catch (Exception e) { + } catch (final Exception e) { s_logger.error("Exception responding to http request", e); } return responseText; } @Override - public String getSerializedApiError(ServerApiException ex, Map apiCommandParams, String responseType) { + public String getSerializedApiError(final ServerApiException ex, final Map apiCommandParams, final String responseType) { String responseName = null; Class cmdClass = null; String responseText = null; @@ -1073,11 +1097,11 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer if (ex.getErrorCode() == ApiErrorCode.UNSUPPORTED_ACTION_ERROR || apiCommandParams == null || apiCommandParams.isEmpty()) { responseName = "errorresponse"; } else { - Object cmdObj = apiCommandParams.get("command"); + final Object cmdObj = apiCommandParams.get(ApiConstants.COMMAND); // cmd name can be null when "command" parameter is missing in // the request if (cmdObj != null) { - String cmdName = ((String[])cmdObj)[0]; + final String cmdName = ((String[])cmdObj)[0]; cmdClass = getCmdClass(cmdName); if (cmdClass != null) { responseName = ((BaseCmd)cmdClass.newInstance()).getCommandName(); @@ -1086,11 +1110,11 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } } } - ExceptionResponse apiResponse = new ExceptionResponse(); + final ExceptionResponse apiResponse = new ExceptionResponse(); apiResponse.setErrorCode(ex.getErrorCode().getHttpCode()); apiResponse.setErrorText(ex.getDescription()); apiResponse.setResponseName(responseName); - ArrayList idList = ex.getIdProxyList(); + final ArrayList idList = ex.getIdProxyList(); if (idList != null) { for (int i = 0; i < idList.size(); i++) { apiResponse.addProxyObject(idList.get(i)); @@ -1103,7 +1127,7 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer SerializationContext.current().setUuidTranslation(true); responseText = ApiResponseSerializer.toSerializedString(apiResponse, responseType); - } catch (Exception e) { + } catch (final Exception e) { s_logger.error("Exception responding to http request", e); } return responseText; @@ -1114,7 +1138,7 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } @Inject - public void setPluggableServices(List pluggableServices) { + public void setPluggableServices(final List pluggableServices) { _pluggableServices = pluggableServices; } @@ -1123,7 +1147,7 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer } @Inject - public void setApiAccessCheckers(List apiAccessCheckers) { + public void setApiAccessCheckers(final List apiAccessCheckers) { _apiAccessCheckers = apiAccessCheckers; } @@ -1131,7 +1155,7 @@ public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiSer return encodeApiResponse; } - private static void setEncodeApiResponse(boolean encodeApiResponse) { + private static void setEncodeApiResponse(final boolean encodeApiResponse) { ApiServer.encodeApiResponse = encodeApiResponse; } diff --git a/server/src/com/cloud/api/ApiServlet.java b/server/src/com/cloud/api/ApiServlet.java index 46f7eba8bee..37a2549edb8 100755 --- a/server/src/com/cloud/api/ApiServlet.java +++ b/server/src/com/cloud/api/ApiServlet.java @@ -35,6 +35,7 @@ import org.apache.log4j.Logger; import org.springframework.stereotype.Component; import org.springframework.web.context.support.SpringBeanAutowiringSupport; +import org.apache.cloudstack.api.ApiConstants; import org.apache.cloudstack.api.ApiErrorCode; import org.apache.cloudstack.api.BaseCmd; import org.apache.cloudstack.api.ServerApiException; @@ -67,40 +68,40 @@ public class ApiServlet extends HttpServlet { } @Override - public void init(ServletConfig config) throws ServletException { + public void init(final ServletConfig config) throws ServletException { SpringBeanAutowiringSupport.processInjectionBasedOnServletContext(this, config.getServletContext()); } @Override - protected void doGet(HttpServletRequest req, HttpServletResponse resp) { + protected void doGet(final HttpServletRequest req, final HttpServletResponse resp) { processRequest(req, resp); } @Override - protected void doPost(HttpServletRequest req, HttpServletResponse resp) { + protected void doPost(final HttpServletRequest req, final HttpServletResponse resp) { processRequest(req, resp); } - private void utf8Fixup(HttpServletRequest req, Map params) { + private void utf8Fixup(final HttpServletRequest req, final Map params) { if (req.getQueryString() == null) { return; } - String[] paramsInQueryString = req.getQueryString().split("&"); + final String[] paramsInQueryString = req.getQueryString().split("&"); if (paramsInQueryString != null) { - for (String param : paramsInQueryString) { - String[] paramTokens = param.split("=", 2); + for (final String param : paramsInQueryString) { + final String[] paramTokens = param.split("=", 2); if (paramTokens != null && paramTokens.length == 2) { String name = paramTokens[0]; String value = paramTokens[1]; try { name = URLDecoder.decode(name, "UTF-8"); - } catch (UnsupportedEncodingException e) { + } catch (final UnsupportedEncodingException e) { } try { value = URLDecoder.decode(value, "UTF-8"); - } catch (UnsupportedEncodingException e) { + } catch (final UnsupportedEncodingException e) { } params.put(name, new String[] {value}); } else { @@ -119,13 +120,13 @@ public class ApiServlet extends HttpServlet { }); } - private void processRequestInContext(HttpServletRequest req, HttpServletResponse resp) { - StringBuffer auditTrailSb = new StringBuffer(); + private void processRequestInContext(final HttpServletRequest req, final HttpServletResponse resp) { + final StringBuffer auditTrailSb = new StringBuffer(); auditTrailSb.append(" " + req.getRemoteAddr()); auditTrailSb.append(" -- " + req.getMethod() + " "); // get the response format since we'll need it in a couple of places String responseType = BaseCmd.RESPONSE_TYPE_XML; - Map params = new HashMap(); + final Map params = new HashMap(); params.putAll(req.getParameterMap()); // For HTTP GET requests, it seems that HttpServletRequest.getParameterMap() actually tries @@ -143,19 +144,19 @@ public class ApiServlet extends HttpServlet { try { HttpSession session = req.getSession(false); - Object[] responseTypeParam = params.get("response"); + final Object[] responseTypeParam = params.get(ApiConstants.RESPONSE); if (responseTypeParam != null) { responseType = (String)responseTypeParam[0]; } - Object[] commandObj = params.get("command"); + final Object[] commandObj = params.get(ApiConstants.COMMAND); if (commandObj != null) { - String command = (String)commandObj[0]; + final String command = (String)commandObj[0]; if ("logout".equalsIgnoreCase(command)) { // if this is just a logout, invalidate the session and return if (session != null) { - Long userId = (Long)session.getAttribute("userid"); - Account account = (Account)session.getAttribute("accountobj"); + final Long userId = (Long)session.getAttribute("userid"); + final Account account = (Account)session.getAttribute("accountobj"); Long accountId = null; if (account != null) { accountId = account.getId(); @@ -166,7 +167,7 @@ public class ApiServlet extends HttpServlet { } try { session.invalidate(); - } catch (IllegalStateException ise) { + } catch (final IllegalStateException ise) { } } auditTrailSb.append("command=logout"); @@ -179,18 +180,18 @@ public class ApiServlet extends HttpServlet { if (session != null) { try { session.invalidate(); - } catch (IllegalStateException ise) { + } catch (final IllegalStateException ise) { } } session = req.getSession(true); - String[] username = (String[])params.get("username"); - String[] password = (String[])params.get("password"); - String[] domainIdArr = (String[])params.get("domainid"); + final String[] username = (String[])params.get(ApiConstants.USERNAME); + final String[] password = (String[])params.get(ApiConstants.PASSWORD); + String[] domainIdArr = (String[])params.get(ApiConstants.DOMAIN_ID); if (domainIdArr == null) { - domainIdArr = (String[])params.get("domainId"); + domainIdArr = (String[])params.get(ApiConstants.DOMAIN__ID); } - String[] domainName = (String[])params.get("domain"); + final String[] domainName = (String[])params.get(ApiConstants.DOMAIN); Long domainId = null; if ((domainIdArr != null) && (domainIdArr.length > 0)) { try { @@ -200,10 +201,10 @@ public class ApiServlet extends HttpServlet { domainId = new Long(Long.parseLong(domainIdArr[0])); } auditTrailSb.append(" domainid=" + domainId);// building the params for POST call - } catch (NumberFormatException e) { + } catch (final NumberFormatException e) { s_logger.warn("Invalid domain id entered by user"); auditTrailSb.append(" " + HttpServletResponse.SC_UNAUTHORIZED + " " + "Invalid domain id entered, please enter a valid one"); - String serializedResponse = + final String serializedResponse = _apiServer.getSerializedApiError(HttpServletResponse.SC_UNAUTHORIZED, "Invalid domain id entered, please enter a valid one", params, responseType); writeResponse(resp, serializedResponse, HttpServletResponse.SC_UNAUTHORIZED, responseType); @@ -225,24 +226,24 @@ public class ApiServlet extends HttpServlet { } if (username != null) { - String pwd = ((password == null) ? null : password[0]); + final String pwd = ((password == null) ? null : password[0]); try { _apiServer.loginUser(session, username[0], pwd, domainId, domain, req.getRemoteAddr(), params); auditTrailSb.insert(0, "(userId=" + session.getAttribute("userid") + " accountId=" + ((Account)session.getAttribute("accountobj")).getId() + " sessionId=" + session.getId() + ")"); - String loginResponse = getLoginSuccessResponse(session, responseType); + final String loginResponse = getLoginSuccessResponse(session, responseType); writeResponse(resp, loginResponse, HttpServletResponse.SC_OK, responseType); return; - } catch (CloudAuthenticationException ex) { + } catch (final CloudAuthenticationException ex) { // TODO: fall through to API key, or just fail here w/ auth error? (HTTP 401) try { session.invalidate(); - } catch (IllegalStateException ise) { + } catch (final IllegalStateException ise) { } auditTrailSb.append(" " + ApiErrorCode.ACCOUNT_ERROR + " " + ex.getMessage() != null ? ex.getMessage() : "failed to authenticate user, check if username/password are correct"); - String serializedResponse = + final String serializedResponse = _apiServer.getSerializedApiError(ApiErrorCode.ACCOUNT_ERROR.getHttpCode(), ex.getMessage() != null ? ex.getMessage() : "failed to authenticate user, check if username/password are correct", params, responseType); writeResponse(resp, serializedResponse, ApiErrorCode.ACCOUNT_ERROR.getHttpCode(), responseType); @@ -252,7 +253,7 @@ public class ApiServlet extends HttpServlet { } } auditTrailSb.append(req.getQueryString()); - boolean isNew = ((session == null) ? true : session.isNew()); + final boolean isNew = ((session == null) ? true : session.isNew()); // Initialize an empty context and we will update it after we have verified the request below, // we no longer rely on web-session here, verifyRequest will populate user/account information @@ -261,17 +262,17 @@ public class ApiServlet extends HttpServlet { if (!isNew) { userId = (Long)session.getAttribute("userid"); - String account = (String)session.getAttribute("account"); - Object accountObj = session.getAttribute("accountobj"); - String sessionKey = (String)session.getAttribute("sessionkey"); - String[] sessionKeyParam = (String[])params.get("sessionkey"); + final String account = (String)session.getAttribute("account"); + final Object accountObj = session.getAttribute("accountobj"); + final String sessionKey = (String)session.getAttribute("sessionkey"); + final String[] sessionKeyParam = (String[])params.get(ApiConstants.SESSIONKEY); if ((sessionKeyParam == null) || (sessionKey == null) || !sessionKey.equals(sessionKeyParam[0])) { try { session.invalidate(); - } catch (IllegalStateException ise) { + } catch (final IllegalStateException ise) { } auditTrailSb.append(" " + HttpServletResponse.SC_UNAUTHORIZED + " " + "unable to verify user credentials"); - String serializedResponse = + final String serializedResponse = _apiServer.getSerializedApiError(HttpServletResponse.SC_UNAUTHORIZED, "unable to verify user credentials", params, responseType); writeResponse(resp, serializedResponse, HttpServletResponse.SC_UNAUTHORIZED, responseType); return; @@ -279,26 +280,26 @@ public class ApiServlet extends HttpServlet { // Do a sanity check here to make sure the user hasn't already been deleted if ((userId != null) && (account != null) && (accountObj != null) && _apiServer.verifyUser(userId)) { - String[] command = (String[])params.get("command"); + final String[] command = (String[])params.get(ApiConstants.COMMAND); if (command == null) { s_logger.info("missing command, ignoring request..."); auditTrailSb.append(" " + HttpServletResponse.SC_BAD_REQUEST + " " + "no command specified"); - String serializedResponse = _apiServer.getSerializedApiError(HttpServletResponse.SC_BAD_REQUEST, "no command specified", params, responseType); + final String serializedResponse = _apiServer.getSerializedApiError(HttpServletResponse.SC_BAD_REQUEST, "no command specified", params, responseType); writeResponse(resp, serializedResponse, HttpServletResponse.SC_BAD_REQUEST, responseType); return; } - User user = _entityMgr.findById(User.class, userId); + final User user = _entityMgr.findById(User.class, userId); CallContext.register(user, (Account)accountObj); } else { // Invalidate the session to ensure we won't allow a request across management server // restarts if the userId was serialized to the stored session try { session.invalidate(); - } catch (IllegalStateException ise) { + } catch (final IllegalStateException ise) { } auditTrailSb.append(" " + HttpServletResponse.SC_UNAUTHORIZED + " " + "unable to verify user credentials"); - String serializedResponse = + final String serializedResponse = _apiServer.getSerializedApiError(HttpServletResponse.SC_UNAUTHORIZED, "unable to verify user credentials", params, responseType); writeResponse(resp, serializedResponse, HttpServletResponse.SC_UNAUTHORIZED, responseType); return; @@ -326,29 +327,29 @@ public class ApiServlet extends HttpServlet { // Add the HTTP method (GET/POST/PUT/DELETE) as well into the params map. params.put("httpmethod", new String[] {req.getMethod()}); - String response = _apiServer.handleRequest(params, responseType, auditTrailSb); + final String response = _apiServer.handleRequest(params, responseType, auditTrailSb); writeResponse(resp, response != null ? response : "", HttpServletResponse.SC_OK, responseType); } else { if (session != null) { try { session.invalidate(); - } catch (IllegalStateException ise) { + } catch (final IllegalStateException ise) { } } auditTrailSb.append(" " + HttpServletResponse.SC_UNAUTHORIZED + " " + "unable to verify user credentials and/or request signature"); - String serializedResponse = + final String serializedResponse = _apiServer.getSerializedApiError(HttpServletResponse.SC_UNAUTHORIZED, "unable to verify user credentials and/or request signature", params, responseType); writeResponse(resp, serializedResponse, HttpServletResponse.SC_UNAUTHORIZED, responseType); } - } catch (ServerApiException se) { - String serializedResponseText = _apiServer.getSerializedApiError(se, params, responseType); + } catch (final ServerApiException se) { + final String serializedResponseText = _apiServer.getSerializedApiError(se, params, responseType); resp.setHeader("X-Description", se.getDescription()); writeResponse(resp, serializedResponseText, se.getErrorCode().getHttpCode(), responseType); auditTrailSb.append(" " + se.getErrorCode() + " " + se.getDescription()); - } catch (Exception ex) { + } catch (final Exception ex) { s_logger.error("unknown exception writing api response", ex); auditTrailSb.append(" unknown exception writing api response"); } finally { @@ -372,7 +373,7 @@ public class ApiServlet extends HttpServlet { */ // FIXME: rather than isError, we might was to pass in the status code to give more flexibility - private void writeResponse(HttpServletResponse resp, String response, int responseCode, String responseType) { + private void writeResponse(final HttpServletResponse resp, final String response, final int responseCode, final String responseType) { try { if (BaseCmd.RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) { resp.setContentType(ApiServer.getJsonContentType() + "; charset=UTF-8"); @@ -382,11 +383,11 @@ public class ApiServlet extends HttpServlet { resp.setStatus(responseCode); resp.getWriter().print(response); - } catch (IOException ioex) { + } catch (final IOException ioex) { if (s_logger.isTraceEnabled()) { s_logger.trace("exception writing response: " + ioex); } - } catch (Exception ex) { + } catch (final Exception ex) { if (!(ex instanceof IllegalStateException)) { s_logger.error("unknown exception writing api response", ex); } @@ -394,29 +395,29 @@ public class ApiServlet extends HttpServlet { } @SuppressWarnings("rawtypes") - private String getLoginSuccessResponse(HttpSession session, String responseType) { - StringBuffer sb = new StringBuffer(); - int inactiveInterval = session.getMaxInactiveInterval(); + private String getLoginSuccessResponse(final HttpSession session, final String responseType) { + final StringBuffer sb = new StringBuffer(); + final int inactiveInterval = session.getMaxInactiveInterval(); - String user_UUID = (String)session.getAttribute("user_UUID"); + final String user_UUID = (String)session.getAttribute("user_UUID"); session.removeAttribute("user_UUID"); - String domain_UUID = (String)session.getAttribute("domain_UUID"); + final String domain_UUID = (String)session.getAttribute("domain_UUID"); session.removeAttribute("domain_UUID"); if (BaseCmd.RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) { sb.append("{ \"loginresponse\" : { "); - Enumeration attrNames = session.getAttributeNames(); + final Enumeration attrNames = session.getAttributeNames(); if (attrNames != null) { sb.append("\"timeout\" : \"" + inactiveInterval + "\""); while (attrNames.hasMoreElements()) { - String attrName = (String)attrNames.nextElement(); + final String attrName = (String)attrNames.nextElement(); if ("userid".equalsIgnoreCase(attrName)) { sb.append(", \"" + attrName + "\" : \"" + user_UUID + "\""); } else if ("domainid".equalsIgnoreCase(attrName)) { sb.append(", \"" + attrName + "\" : \"" + domain_UUID + "\""); } else { - Object attrObj = session.getAttribute(attrName); + final Object attrObj = session.getAttribute(attrName); if ((attrObj instanceof String) || (attrObj instanceof Long)) { sb.append(", \"" + attrName + "\" : \"" + attrObj.toString() + "\""); } @@ -428,16 +429,16 @@ public class ApiServlet extends HttpServlet { sb.append(""); sb.append(""); sb.append("" + inactiveInterval + ""); - Enumeration attrNames = session.getAttributeNames(); + final Enumeration attrNames = session.getAttributeNames(); if (attrNames != null) { while (attrNames.hasMoreElements()) { - String attrName = (String)attrNames.nextElement(); - if ("userid".equalsIgnoreCase(attrName)) { + final String attrName = (String)attrNames.nextElement(); + if (ApiConstants.USER_ID.equalsIgnoreCase(attrName)) { sb.append("<" + attrName + ">" + user_UUID + ""); } else if ("domainid".equalsIgnoreCase(attrName)) { sb.append("<" + attrName + ">" + domain_UUID + ""); } else { - Object attrObj = session.getAttribute(attrName); + final Object attrObj = session.getAttribute(attrName); if (attrObj instanceof String || attrObj instanceof Long || attrObj instanceof Short) { sb.append("<" + attrName + ">" + attrObj.toString() + ""); } @@ -450,8 +451,8 @@ public class ApiServlet extends HttpServlet { return sb.toString(); } - private String getLogoutSuccessResponse(String responseType) { - StringBuffer sb = new StringBuffer(); + private String getLogoutSuccessResponse(final String responseType) { + final StringBuffer sb = new StringBuffer(); if (BaseCmd.RESPONSE_TYPE_JSON.equalsIgnoreCase(responseType)) { sb.append("{ \"logoutresponse\" : { \"description\" : \"success\" } }"); } else { diff --git a/server/src/com/cloud/api/dispatch/CommandCreationWorker.java b/server/src/com/cloud/api/dispatch/CommandCreationWorker.java new file mode 100644 index 00000000000..30d4637d373 --- /dev/null +++ b/server/src/com/cloud/api/dispatch/CommandCreationWorker.java @@ -0,0 +1,56 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import org.apache.cloudstack.api.ApiErrorCode; +import org.apache.cloudstack.api.BaseAsyncCreateCmd; +import org.apache.cloudstack.api.BaseCmd; +import org.apache.cloudstack.api.ServerApiException; + +import com.cloud.exception.ResourceAllocationException; + + +/** + * This worker invokes create on the {@link BaseCmd} itself + * + * @author afornie + */ +public class CommandCreationWorker implements DispatchWorker { + + private static final String ATTEMP_TO_CREATE_NON_CREATION_CMD = + "Trying to invoke creation on a Command that is not " + + BaseAsyncCreateCmd.class.getName(); + + @Override + public void handle(final DispatchTask task) { + final BaseCmd cmd = task.getCmd(); + + if (cmd instanceof BaseAsyncCreateCmd) { + try { + ((BaseAsyncCreateCmd)cmd).create(); + } catch (final ResourceAllocationException e) { + throw new ServerApiException(ApiErrorCode.RESOURCE_ALLOCATION_ERROR, + e.getMessage(), e); + } + } else { + throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, + ATTEMP_TO_CREATE_NON_CREATION_CMD); + } + } + +} diff --git a/server/src/com/cloud/api/dispatch/DispatchChain.java b/server/src/com/cloud/api/dispatch/DispatchChain.java new file mode 100644 index 00000000000..0ce0ce011e3 --- /dev/null +++ b/server/src/com/cloud/api/dispatch/DispatchChain.java @@ -0,0 +1,40 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import java.util.ArrayList; +import java.util.List; +import org.apache.cloudstack.api.ServerApiException; + +public class DispatchChain { + + protected List workers = new ArrayList(); + + public DispatchChain add(final DispatchWorker worker) { + workers.add(worker); + return this; + } + + public void dispatch(final DispatchTask task) + throws ServerApiException { + + for (final DispatchWorker worker : workers) { + worker.handle(task); + } + } +} diff --git a/server/src/com/cloud/api/dispatch/DispatchChainFactory.java b/server/src/com/cloud/api/dispatch/DispatchChainFactory.java new file mode 100644 index 00000000000..135829ec4b8 --- /dev/null +++ b/server/src/com/cloud/api/dispatch/DispatchChainFactory.java @@ -0,0 +1,72 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import javax.annotation.PostConstruct; +import javax.inject.Inject; + +import com.cloud.user.AccountManager; + +public class DispatchChainFactory { + + @Inject + protected AccountManager _accountMgr; + + @Inject + protected ParamGenericValidationWorker paramGenericValidationWorker; + + @Inject + protected ParamUnpackWorker paramUnpackWorker; + + @Inject + protected ParamProcessWorker paramProcessWorker; + + @Inject + protected SpecificCmdValidationWorker specificCmdValidationWorker; + + @Inject + protected CommandCreationWorker commandCreationWorker; + + protected DispatchChain standardDispatchChain; + + protected DispatchChain asyncCreationDispatchChain; + + @PostConstruct + public void setup() { + standardDispatchChain = new DispatchChain(). + add(paramUnpackWorker). + add(paramProcessWorker). + add(paramGenericValidationWorker). + add(specificCmdValidationWorker); + + asyncCreationDispatchChain = new DispatchChain(). + add(paramUnpackWorker). + add(paramProcessWorker). + add(paramGenericValidationWorker). + add(specificCmdValidationWorker). + add(commandCreationWorker); + } + + public DispatchChain getStandardDispatchChain() { + return standardDispatchChain; + } + + public DispatchChain getAsyncCreationDispatchChain() { + return asyncCreationDispatchChain; + } +} diff --git a/server/src/com/cloud/api/dispatch/DispatchTask.java b/server/src/com/cloud/api/dispatch/DispatchTask.java new file mode 100644 index 00000000000..2a8a4bdd505 --- /dev/null +++ b/server/src/com/cloud/api/dispatch/DispatchTask.java @@ -0,0 +1,41 @@ +package com.cloud.api.dispatch; + +import java.util.Map; + +import org.apache.cloudstack.api.BaseCmd; + +/** + * This class wraps all the data that any worker could need. If we don't wrap it this + * way and we pass the parameters one by one, in the end we could end up having all the + * N workers receiving plenty of parameters and changing the signature, each time one + * of them changes. This way, if a certain worker needs something else, you just need + * to change it in this wrapper class and the worker itself. + */ +@SuppressWarnings("rawtypes") +public class DispatchTask { + + protected BaseCmd cmd; + + protected Map params; + + public DispatchTask(final BaseCmd cmd, final Map params) { + this.cmd = cmd; + this.params = params; + } + + public BaseCmd getCmd() { + return cmd; + } + + public void setCmd(final BaseCmd cmd) { + this.cmd = cmd; + } + + public Map getParams() { + return params; + } + + public void setParams(final Map params) { + this.params = params; + } +} diff --git a/server/src/com/cloud/api/dispatch/DispatchWorker.java b/server/src/com/cloud/api/dispatch/DispatchWorker.java new file mode 100644 index 00000000000..a0dbc6a88a5 --- /dev/null +++ b/server/src/com/cloud/api/dispatch/DispatchWorker.java @@ -0,0 +1,30 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import org.apache.cloudstack.api.ServerApiException; + +/** + * Describes the behavior of the workers in the Chain of Responsibility, that receive and + * work on a {@link DispatchTask} which will then be passed to next workers. + */ +public interface DispatchWorker { + + public void handle(DispatchTask task) + throws ServerApiException; +} diff --git a/server/src/com/cloud/api/dispatch/ParamGenericValidationWorker.java b/server/src/com/cloud/api/dispatch/ParamGenericValidationWorker.java new file mode 100644 index 00000000000..0c829e8db07 --- /dev/null +++ b/server/src/com/cloud/api/dispatch/ParamGenericValidationWorker.java @@ -0,0 +1,103 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import java.lang.reflect.Field; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +import org.apache.cloudstack.api.ApiConstants; +import org.apache.cloudstack.api.BaseCmd; +import org.apache.cloudstack.api.Parameter; +import org.apache.log4j.Logger; + +/** + * This worker validates parameters in a generic way, by using annotated + * restrictions without involving the {@Link BaseCmd}. This worker doesn't + * know or care about the meaning of the parameters and that's why we can + * have it out of the {@Link BaseCmd} + * + * @author afornie + */ +public class ParamGenericValidationWorker implements DispatchWorker { + + protected static Logger s_logger = Logger.getLogger(ParamGenericValidationWorker.class.getName()); + + protected static List defaultParamNames = new ArrayList(); + + static { + defaultParamNames.add(ApiConstants.CTX_START_EVENT_ID); + defaultParamNames.add(ApiConstants.COMMAND); + defaultParamNames.add(ApiConstants.CMD_EVENT_TYPE); + defaultParamNames.add(ApiConstants.USERNAME); + defaultParamNames.add(ApiConstants.USER_ID); + defaultParamNames.add(ApiConstants.PASSWORD); + defaultParamNames.add(ApiConstants.DOMAIN); + defaultParamNames.add(ApiConstants.DOMAIN_ID); + defaultParamNames.add(ApiConstants.DOMAIN__ID); + defaultParamNames.add(ApiConstants.SESSIONKEY); + defaultParamNames.add(ApiConstants.RESPONSE); + defaultParamNames.add(ApiConstants.PAGE); + defaultParamNames.add(ApiConstants.USER_API_KEY); + defaultParamNames.add(ApiConstants.API_KEY); + defaultParamNames.add(ApiConstants.PAGE_SIZE); + defaultParamNames.add(ApiConstants.HTTPMETHOD); + defaultParamNames.add(ApiConstants.SIGNATURE); + defaultParamNames.add(ApiConstants.CTX_ACCOUNT_ID); + defaultParamNames.add(ApiConstants.CTX_START_EVENT_ID); + defaultParamNames.add(ApiConstants.CTX_USER_ID); + defaultParamNames.add("_"); + } + + protected static final String ERROR_MSG_PREFIX = "Unknown parameters :"; + + @SuppressWarnings("rawtypes") + @Override + public void handle(final DispatchTask task) { + final BaseCmd cmd = task.getCmd(); + final Map params = task.getParams(); + + final List expectedParamNames = getParamNamesForCommand(cmd); + + final StringBuilder errorMsg = new StringBuilder(ERROR_MSG_PREFIX); + boolean foundUnknownParam = false; + for (final Object paramName : params.keySet()) { + if (!expectedParamNames.contains(paramName)) { + errorMsg.append(" ").append(paramName); + foundUnknownParam= true; + } + } + + if (foundUnknownParam) { + s_logger.warn(String.format("Received unknown parameters for command %s. %s", cmd.getActualCommandName(), errorMsg)); + } + } + + protected List getParamNamesForCommand(final BaseCmd cmd) { + final List paramNames = new ArrayList(); + // The expected param names are all the specific for the current command class ... + for (final Field field : cmd.getParamFields()) { + final Parameter parameterAnnotation = field.getAnnotation(Parameter.class); + paramNames.add(parameterAnnotation.name()); + } + // ... plus the default ones + paramNames.addAll(defaultParamNames); + return paramNames; + } +} diff --git a/server/src/com/cloud/api/dispatch/ParamProcessWorker.java b/server/src/com/cloud/api/dispatch/ParamProcessWorker.java new file mode 100644 index 00000000000..e9bdd8b107b --- /dev/null +++ b/server/src/com/cloud/api/dispatch/ParamProcessWorker.java @@ -0,0 +1,428 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import static org.apache.commons.lang.StringUtils.isNotBlank; + +import java.lang.reflect.Field; +import java.text.DateFormat; +import java.text.ParseException; +import java.util.ArrayList; +import java.util.Calendar; +import java.util.Date; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.StringTokenizer; +import java.util.regex.Matcher; + +import javax.inject.Inject; + +import org.apache.log4j.Logger; + +import org.apache.cloudstack.acl.ControlledEntity; +import org.apache.cloudstack.acl.InfrastructureEntity; +import org.apache.cloudstack.acl.SecurityChecker.AccessType; +import org.apache.cloudstack.api.ACL; +import org.apache.cloudstack.api.ApiErrorCode; +import org.apache.cloudstack.api.BaseAsyncCreateCmd; +import org.apache.cloudstack.api.BaseCmd; +import org.apache.cloudstack.api.EntityReference; +import org.apache.cloudstack.api.InternalIdentity; +import org.apache.cloudstack.api.Parameter; +import org.apache.cloudstack.api.ServerApiException; +import org.apache.cloudstack.api.BaseCmd.CommandType; +import org.apache.cloudstack.api.command.admin.resource.ArchiveAlertsCmd; +import org.apache.cloudstack.api.command.admin.resource.DeleteAlertsCmd; +import org.apache.cloudstack.api.command.user.event.ArchiveEventsCmd; +import org.apache.cloudstack.api.command.user.event.DeleteEventsCmd; +import org.apache.cloudstack.api.command.user.event.ListEventsCmd; +import org.apache.cloudstack.context.CallContext; + +import com.cloud.exception.InvalidParameterValueException; +import com.cloud.user.Account; +import com.cloud.user.AccountManager; +import com.cloud.utils.DateUtil; +import com.cloud.utils.db.EntityManager; +import com.cloud.utils.exception.CloudRuntimeException; + +public class ParamProcessWorker implements DispatchWorker { + + private static final Logger s_logger = Logger.getLogger(ParamProcessWorker.class.getName()); + + @Inject + protected AccountManager _accountMgr; + + @Inject + protected EntityManager _entityMgr; + + @Override + public void handle(final DispatchTask task) { + processParameters(task.getCmd(), task.getParams()); + } + + @SuppressWarnings({"unchecked", "rawtypes"}) + public void processParameters(final BaseCmd cmd, final Map params) { + final Map entitiesToAccess = new HashMap(); + + final List cmdFields = cmd.getParamFields(); + + for (final Field field : cmdFields) { + final Parameter parameterAnnotation = field.getAnnotation(Parameter.class); + final Object paramObj = params.get(parameterAnnotation.name()); + if (paramObj == null) { + if (parameterAnnotation.required()) { + throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Unable to execute API command " + + cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8) + + " due to missing parameter " + parameterAnnotation.name()); + } + continue; + } + + // marshall the parameter into the correct type and set the field value + try { + setFieldValue(field, cmd, paramObj, parameterAnnotation); + } catch (final IllegalArgumentException argEx) { + if (s_logger.isDebugEnabled()) { + s_logger.debug("Unable to execute API command " + cmd.getCommandName() + " due to invalid value " + paramObj + " for parameter " + + parameterAnnotation.name()); + } + throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Unable to execute API command " + + cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8) + " due to invalid value " + paramObj + " for parameter " + + parameterAnnotation.name()); + } catch (final ParseException parseEx) { + if (s_logger.isDebugEnabled()) { + s_logger.debug("Invalid date parameter " + paramObj + " passed to command " + cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8)); + } + throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Unable to parse date " + paramObj + " for command " + + cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8) + ", please pass dates in the format mentioned in the api documentation"); + } catch (final InvalidParameterValueException invEx) { + throw new ServerApiException(ApiErrorCode.PARAM_ERROR, "Unable to execute API command " + + cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8) + " due to invalid value. " + invEx.getMessage()); + } catch (final CloudRuntimeException cloudEx) { + s_logger.error("CloudRuntimeException", cloudEx); + // FIXME: Better error message? This only happens if the API command is not executable, which typically + //means + // there was + // and IllegalAccessException setting one of the parameters. + throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, "Internal error executing API command " + + cmd.getCommandName().substring(0, cmd.getCommandName().length() - 8)); + } + + //check access on the resource this field points to + try { + final ACL checkAccess = field.getAnnotation(ACL.class); + final CommandType fieldType = parameterAnnotation.type(); + + if (checkAccess != null) { + // Verify that caller can perform actions in behalf of vm owner + //acumulate all Controlled Entities together. + + //parse the array of resource types and in case of map check access on key or value or both as specified in @acl + //implement external dao for classes that need findByName + //for maps, specify access to be checkd on key or value. + + // find the controlled entity DBid by uuid + if (parameterAnnotation.entityType() != null) { + final Class[] entityList = parameterAnnotation.entityType()[0].getAnnotation(EntityReference.class).value(); + + for (final Class entity : entityList) { + // Check if the parameter type is a single + // Id or list of id's/name's + switch (fieldType) { + case LIST: + final CommandType listType = parameterAnnotation.collectionType(); + switch (listType) { + case LONG: + case UUID: + final List listParam = (List)field.get(cmd); + for (final Long entityId : listParam) { + final Object entityObj = _entityMgr.findById(entity, entityId); + entitiesToAccess.put(entityObj, checkAccess.accessType()); + } + break; + /* + * case STRING: List listParam = + * new ArrayList(); listParam = + * (List)field.get(cmd); for(String + * entityName: listParam){ + * ControlledEntity entityObj = + * (ControlledEntity + * )daoClassInstance(entityId); + * entitiesToAccess.add(entityObj); } + * break; + */ + default: + break; + } + break; + case LONG: + case UUID: + final Object entityObj = _entityMgr.findById(entity, (Long)field.get(cmd)); + entitiesToAccess.put(entityObj, checkAccess.accessType()); + break; + default: + break; + } + + if (ControlledEntity.class.isAssignableFrom(entity)) { + if (s_logger.isDebugEnabled()) { + s_logger.debug("ControlledEntity name is:" + entity.getName()); + } + } + + if (InfrastructureEntity.class.isAssignableFrom(entity)) { + if (s_logger.isDebugEnabled()) { + s_logger.debug("InfrastructureEntity name is:" + entity.getName()); + } + } + } + + } + + } + + } catch (final IllegalArgumentException e) { + s_logger.error("Error initializing command " + cmd.getCommandName() + ", field " + field.getName() + " is not accessible."); + throw new CloudRuntimeException("Internal error initializing parameters for command " + cmd.getCommandName() + " [field " + field.getName() + + " is not accessible]"); + } catch (final IllegalAccessException e) { + s_logger.error("Error initializing command " + cmd.getCommandName() + ", field " + field.getName() + " is not accessible."); + throw new CloudRuntimeException("Internal error initializing parameters for command " + cmd.getCommandName() + " [field " + field.getName() + + " is not accessible]"); + } + + } + + doAccessChecks(cmd, entitiesToAccess); + } + + + private void doAccessChecks(final BaseCmd cmd, final Map entitiesToAccess) { + final Account caller = CallContext.current().getCallingAccount(); + final Account owner = _accountMgr.getActiveAccountById(cmd.getEntityOwnerId()); + + if (cmd instanceof BaseAsyncCreateCmd) { + //check that caller can access the owner account. + _accountMgr.checkAccess(caller, null, true, owner); + } + + if (!entitiesToAccess.isEmpty()) { + //check that caller can access the owner account. + _accountMgr.checkAccess(caller, null, true, owner); + for (final Object entity : entitiesToAccess.keySet()) { + if (entity instanceof ControlledEntity) { + _accountMgr.checkAccess(caller, entitiesToAccess.get(entity), true, (ControlledEntity)entity); + } else if (entity instanceof InfrastructureEntity) { + //FIXME: Move this code in adapter, remove code from Account manager + } + } + } + } + + + @SuppressWarnings({"unchecked", "rawtypes"}) + private void setFieldValue(final Field field, final BaseCmd cmdObj, final Object paramObj, final Parameter annotation) throws IllegalArgumentException, ParseException { + try { + field.setAccessible(true); + final CommandType fieldType = annotation.type(); + switch (fieldType) { + case BOOLEAN: + field.set(cmdObj, Boolean.valueOf(paramObj.toString())); + break; + case DATE: + // This piece of code is for maintaining backward compatibility + // and support both the date formats(Bug 9724) + // Do the date messaging for ListEventsCmd only + if (cmdObj instanceof ListEventsCmd || cmdObj instanceof DeleteEventsCmd || cmdObj instanceof ArchiveEventsCmd || + cmdObj instanceof ArchiveAlertsCmd || cmdObj instanceof DeleteAlertsCmd) { + final boolean isObjInNewDateFormat = isObjInNewDateFormat(paramObj.toString()); + if (isObjInNewDateFormat) { + final DateFormat newFormat = BaseCmd.NEW_INPUT_FORMAT; + synchronized (newFormat) { + field.set(cmdObj, newFormat.parse(paramObj.toString())); + } + } else { + final DateFormat format = BaseCmd.INPUT_FORMAT; + synchronized (format) { + Date date = format.parse(paramObj.toString()); + if (field.getName().equals("startDate")) { + date = messageDate(date, 0, 0, 0); + } else if (field.getName().equals("endDate")) { + date = messageDate(date, 23, 59, 59); + } + field.set(cmdObj, date); + } + } + } else { + final DateFormat format = BaseCmd.INPUT_FORMAT; + synchronized (format) { + format.setLenient(false); + field.set(cmdObj, format.parse(paramObj.toString())); + } + } + break; + case FLOAT: + // Assuming that the parameters have been checked for required before now, + // we ignore blank or null values and defer to the command to set a default + // value for optional parameters ... + if (paramObj != null && isNotBlank(paramObj.toString())) { + field.set(cmdObj, Float.valueOf(paramObj.toString())); + } + break; + case INTEGER: + // Assuming that the parameters have been checked for required before now, + // we ignore blank or null values and defer to the command to set a default + // value for optional parameters ... + if (paramObj != null && isNotBlank(paramObj.toString())) { + field.set(cmdObj, Integer.valueOf(paramObj.toString())); + } + break; + case LIST: + final List listParam = new ArrayList(); + final StringTokenizer st = new StringTokenizer(paramObj.toString(), ","); + while (st.hasMoreTokens()) { + final String token = st.nextToken(); + final CommandType listType = annotation.collectionType(); + switch (listType) { + case INTEGER: + listParam.add(Integer.valueOf(token)); + break; + case UUID: + if (token.isEmpty()) + break; + final Long internalId = translateUuidToInternalId(token, annotation); + listParam.add(internalId); + break; + case LONG: { + listParam.add(Long.valueOf(token)); + } + break; + case SHORT: + listParam.add(Short.valueOf(token)); + case STRING: + listParam.add(token); + break; + } + } + field.set(cmdObj, listParam); + break; + case UUID: + if (paramObj.toString().isEmpty()) + break; + final Long internalId = translateUuidToInternalId(paramObj.toString(), annotation); + field.set(cmdObj, internalId); + break; + case LONG: + field.set(cmdObj, Long.valueOf(paramObj.toString())); + break; + case SHORT: + field.set(cmdObj, Short.valueOf(paramObj.toString())); + break; + case STRING: + if ((paramObj != null) && paramObj.toString().length() > annotation.length()) { + s_logger.error("Value greater than max allowed length " + annotation.length() + " for param: " + field.getName()); + throw new InvalidParameterValueException("Value greater than max allowed length " + annotation.length() + " for param: " + field.getName()); + } + field.set(cmdObj, paramObj.toString()); + break; + case TZDATE: + field.set(cmdObj, DateUtil.parseTZDateString(paramObj.toString())); + break; + case MAP: + default: + field.set(cmdObj, paramObj); + break; + } + } catch (final IllegalAccessException ex) { + s_logger.error("Error initializing command " + cmdObj.getCommandName() + ", field " + field.getName() + " is not accessible."); + throw new CloudRuntimeException("Internal error initializing parameters for command " + cmdObj.getCommandName() + " [field " + field.getName() + + " is not accessible]"); + } + } + + private boolean isObjInNewDateFormat(final String string) { + final Matcher matcher = BaseCmd.newInputDateFormat.matcher(string); + return matcher.matches(); + } + + private Date messageDate(final Date date, final int hourOfDay, final int minute, final int second) { + final Calendar cal = Calendar.getInstance(); + cal.setTime(date); + cal.set(Calendar.HOUR_OF_DAY, hourOfDay); + cal.set(Calendar.MINUTE, minute); + cal.set(Calendar.SECOND, second); + return cal.getTime(); + } + + private Long translateUuidToInternalId(final String uuid, final Parameter annotation) { + if (uuid.equals("-1")) { + // FIXME: This is to handle a lot of hardcoded special cases where -1 is sent + // APITODO: Find and get rid of all hardcoded params in API Cmds and service layer + return -1L; + } + Long internalId = null; + // If annotation's empty, the cmd existed before 3.x try conversion to long + final boolean isPre3x = annotation.since().isEmpty(); + // Match against Java's UUID regex to check if input is uuid string + final boolean isUuid = uuid.matches("^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$"); + // Enforce that it's uuid for newly added apis from version 3.x + if (!isPre3x && !isUuid) + return null; + // Allow both uuid and internal id for pre3x apis + if (isPre3x && !isUuid) { + try { + internalId = Long.parseLong(uuid); + } catch (final NumberFormatException e) { + internalId = null; + } + if (internalId != null) + return internalId; + } + // There may be multiple entities defined on the @EntityReference of a Response.class + // UUID CommandType would expect only one entityType, so use the first entityType + final Class[] entities = annotation.entityType()[0].getAnnotation(EntityReference.class).value(); + // Go through each entity which is an interface to a VO class and get a VO object + // Try to getId() for the object using reflection, break on first non-null value + for (final Class entity : entities) { + // For backward compatibility, we search within removed entities and let service layer deal + // with removed ones, return empty response or error + final Object objVO = _entityMgr.findByUuidIncludingRemoved(entity, uuid); + if (objVO == null) { + continue; + } + // Invoke the getId method, get the internal long ID + // If that fails hide exceptions as the uuid may not exist + try { + internalId = ((InternalIdentity)objVO).getId(); + } catch (final IllegalArgumentException e) { + } catch (final NullPointerException e) { + } + // Return on first non-null Id for the uuid entity + if (internalId != null) + break; + } + if (internalId == null) { + if (s_logger.isDebugEnabled()) + s_logger.debug("Object entity uuid = " + uuid + " does not exist in the database."); + throw new InvalidParameterValueException("Invalid parameter " + annotation.name() + " value=" + uuid + + " due to incorrect long value format, or entity does not exist or due to incorrect parameter annotation for the field in api cmd class."); + } + return internalId; + } +} diff --git a/server/src/com/cloud/api/dispatch/ParamUnpackWorker.java b/server/src/com/cloud/api/dispatch/ParamUnpackWorker.java new file mode 100644 index 00000000000..12e12265d4d --- /dev/null +++ b/server/src/com/cloud/api/dispatch/ParamUnpackWorker.java @@ -0,0 +1,114 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.log4j.Logger; + +import org.apache.cloudstack.api.ApiErrorCode; +import org.apache.cloudstack.api.ServerApiException; + +public class ParamUnpackWorker implements DispatchWorker { + + private static final Logger s_logger = Logger.getLogger(ParamUnpackWorker.class); + + @SuppressWarnings({"unchecked", "rawtypes"}) + @Override + public void handle(final DispatchTask task) throws ServerApiException { + final Map lowercaseParams = new HashMap(); + final Map params = task.getParams(); + for (final String key : params.keySet()) { + final int arrayStartIndex = key.indexOf('['); + final int arrayStartLastIndex = key.lastIndexOf('['); + if (arrayStartIndex != arrayStartLastIndex) { + throw new ServerApiException(ApiErrorCode.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) { + final int arrayEndIndex = key.indexOf(']'); + final int arrayEndLastIndex = key.lastIndexOf(']'); + if ((arrayEndIndex < arrayStartIndex) || (arrayEndIndex != arrayEndLastIndex)) { + // malformed parameter + throw new ServerApiException(ApiErrorCode.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 + final int fieldIndex = key.indexOf('.'); + String fieldName = null; + if (fieldIndex < arrayEndIndex) { + throw new ServerApiException(ApiErrorCode.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 mapArray = null; + Map mapValue = null; + final String indexStr = key.substring(arrayStartIndex + 1, arrayEndIndex); + int index = 0; + boolean parsedIndex = false; + try { + if (indexStr != null) { + index = Integer.parseInt(indexStr); + parsedIndex = true; + } + } catch (final NumberFormatException nfe) { + s_logger.warn("Invalid parameter " + key + " received, unable to parse object array, returning an error."); + } + + if (!parsedIndex) { + throw new ServerApiException(ApiErrorCode.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"); + } + + final Object value = lowercaseParams.get(paramName); + if (value == null) { + // for now, assume object array with sub fields + mapArray = new HashMap(); + mapValue = new HashMap(); + 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(); + 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, params.get(key)); + + lowercaseParams.put(paramName, mapArray); + } else { + lowercaseParams.put(key.toLowerCase(), params.get(key)); + } + } + + // The chain continues processing the unpacked parameters + task.setParams(lowercaseParams); + } + +} diff --git a/server/src/com/cloud/api/dispatch/SpecificCmdValidationWorker.java b/server/src/com/cloud/api/dispatch/SpecificCmdValidationWorker.java new file mode 100644 index 00000000000..3566a1ad411 --- /dev/null +++ b/server/src/com/cloud/api/dispatch/SpecificCmdValidationWorker.java @@ -0,0 +1,34 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +/** + * This worker validates parameters in a semantic way, that is of + * course specific for each {@link BaseCmd}, so actually it delegates + * the validation on the {@link BaseCmd} itself + * + */ +public class SpecificCmdValidationWorker implements DispatchWorker { + + @SuppressWarnings("unchecked") + @Override + public void handle(final DispatchTask task) { + task.getCmd().validateSpecificParameters(task.getParams()); + } + +} diff --git a/server/src/com/cloud/network/as/AutoScaleManagerImpl.java b/server/src/com/cloud/network/as/AutoScaleManagerImpl.java index 208b4a42cfd..2fa3821c7a5 100644 --- a/server/src/com/cloud/network/as/AutoScaleManagerImpl.java +++ b/server/src/com/cloud/network/as/AutoScaleManagerImpl.java @@ -53,10 +53,12 @@ import org.apache.cloudstack.api.command.user.vm.DeployVMCmd; import org.apache.cloudstack.config.ApiServiceConfiguration; import org.apache.cloudstack.context.CallContext; import org.apache.cloudstack.framework.config.dao.ConfigurationDao; + import org.apache.log4j.Logger; import com.cloud.api.ApiDBUtils; -import com.cloud.api.ApiDispatcher; +import com.cloud.api.dispatch.DispatchChainFactory; +import com.cloud.api.dispatch.DispatchTask; import com.cloud.configuration.ConfigurationManager; import com.cloud.dc.DataCenter; import com.cloud.dc.DataCenter.NetworkType; @@ -118,14 +120,17 @@ import com.cloud.utils.db.TransactionStatus; import com.cloud.utils.net.NetUtils; import com.cloud.vm.UserVmManager; import com.cloud.vm.UserVmService; + import com.google.gson.Gson; import com.google.gson.reflect.TypeToken; @Local(value = {AutoScaleService.class, AutoScaleManager.class}) public class AutoScaleManagerImpl extends ManagerBase implements AutoScaleManager, AutoScaleService { private static final Logger s_logger = Logger.getLogger(AutoScaleManagerImpl.class); - private ScheduledExecutorService _executor = Executors.newScheduledThreadPool(1); + private final ScheduledExecutorService _executor = Executors.newScheduledThreadPool(1); + @Inject() + protected DispatchChainFactory dispatchChainFactory = null; @Inject EntityManager _entityMgr; @Inject @@ -179,35 +184,35 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Inject LoadBalancingRulesService _loadBalancingRulesService; - public List getSupportedAutoScaleCounters(long networkid) { - String capability = _lbRulesMgr.getLBCapability(networkid, Capability.AutoScaleCounters.getName()); + public List getSupportedAutoScaleCounters(final long networkid) { + final String capability = _lbRulesMgr.getLBCapability(networkid, Capability.AutoScaleCounters.getName()); if (capability == null) { return null; } - Gson gson = new Gson(); - java.lang.reflect.Type listType = new TypeToken>() { + final Gson gson = new Gson(); + final java.lang.reflect.Type listType = new TypeToken>() { }.getType(); - List result = gson.fromJson(capability, listType); + final List result = gson.fromJson(capability, listType); return result; } - public void validateAutoScaleCounters(long networkid, List counters, List> counterParamPassed) { - List supportedCounters = getSupportedAutoScaleCounters(networkid); + public void validateAutoScaleCounters(final long networkid, final List counters, final List> counterParamPassed) { + final List supportedCounters = getSupportedAutoScaleCounters(networkid); if (supportedCounters == null) { throw new InvalidParameterException("AutoScale is not supported in the network"); } - for (Counter counter : counters) { - String counterName = counter.getSource().name().toString(); + for (final Counter counter : counters) { + final String counterName = counter.getSource().name().toString(); boolean isCounterSupported = false; - for (AutoScaleCounter autoScaleCounter : supportedCounters) { + for (final AutoScaleCounter autoScaleCounter : supportedCounters) { if (autoScaleCounter.getName().equals(counterName)) { isCounterSupported = true; - List counterParams = autoScaleCounter.getParamList(); - for (AutoScaleCounterParam autoScaleCounterParam : counterParams) { - boolean isRequiredParameter = autoScaleCounterParam.getRequired(); + final List counterParams = autoScaleCounter.getParamList(); + for (final AutoScaleCounterParam autoScaleCounterParam : counterParams) { + final boolean isRequiredParameter = autoScaleCounterParam.getRequired(); if (isRequiredParameter) { boolean isRequiredParamPresent = false; - for (Pair pair : counterParamPassed) { + for (final Pair pair : counterParamPassed) { if (pair.first().equals(autoScaleCounterParam.getParamName())) isRequiredParamPresent = true; @@ -227,9 +232,9 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } } - private VO getEntityInDatabase(Account caller, String paramName, Long id, GenericDao dao) { + private VO getEntityInDatabase(final Account caller, final String paramName, final Long id, final GenericDao dao) { - VO vo = dao.findById(id); + final VO vo = dao.findById(id); if (vo == null) { throw new InvalidParameterValueException("Unable to find " + paramName); @@ -240,27 +245,27 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale return vo; } - private boolean isAutoScaleScaleUpPolicy(AutoScalePolicy policyVO) { + private boolean isAutoScaleScaleUpPolicy(final AutoScalePolicy policyVO) { return policyVO.getAction().equals("scaleup"); } - private List getAutoScalePolicies(String paramName, List policyIds, List counters, int interval, boolean scaleUpPolicies) { - SearchBuilder policySearch = _autoScalePolicyDao.createSearchBuilder(); + private List getAutoScalePolicies(final String paramName, final List policyIds, final List counters, final int interval, final boolean scaleUpPolicies) { + final SearchBuilder policySearch = _autoScalePolicyDao.createSearchBuilder(); policySearch.and("ids", policySearch.entity().getId(), Op.IN); policySearch.done(); - SearchCriteria sc = policySearch.create(); + final SearchCriteria sc = policySearch.create(); sc.setParameters("ids", policyIds.toArray(new Object[0])); - List policies = _autoScalePolicyDao.search(sc, null); + final List policies = _autoScalePolicyDao.search(sc, null); int prevQuietTime = 0; - for (AutoScalePolicyVO policy : policies) { - int quietTime = policy.getQuietTime(); + for (final AutoScalePolicyVO policy : policies) { + final int quietTime = policy.getQuietTime(); if (prevQuietTime == 0) { prevQuietTime = quietTime; } - int duration = policy.getDuration(); + final int duration = policy.getDuration(); if (duration < interval) { throw new InvalidParameterValueException("duration : " + duration + " specified in a policy cannot be less than vm group's interval : " + interval); } @@ -278,11 +283,11 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale throw new InvalidParameterValueException("Only scaledown policies can be specified in scaledownpolicyids"); } } - List policyConditionMapVOs = _autoScalePolicyConditionMapDao.listByAll(policy.getId(), null); - for (AutoScalePolicyConditionMapVO policyConditionMapVO : policyConditionMapVOs) { - long conditionid = policyConditionMapVO.getConditionId(); - Condition condition = _conditionDao.findById(conditionid); - Counter counter = _counterDao.findById(condition.getCounterid()); + final List policyConditionMapVOs = _autoScalePolicyConditionMapDao.listByAll(policy.getId(), null); + for (final AutoScalePolicyConditionMapVO policyConditionMapVO : policyConditionMapVOs) { + final long conditionid = policyConditionMapVO.getConditionId(); + final Condition condition = _conditionDao.findById(conditionid); + final Counter counter = _counterDao.findById(condition.getCounterid()); counters.add(counter); } } @@ -291,11 +296,11 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @DB protected AutoScaleVmProfileVO checkValidityAndPersist(AutoScaleVmProfileVO vmProfile) { - long templateId = vmProfile.getTemplateId(); - long autoscaleUserId = vmProfile.getAutoScaleUserId(); - int destroyVmGraceperiod = vmProfile.getDestroyVmGraceperiod(); + final long templateId = vmProfile.getTemplateId(); + final long autoscaleUserId = vmProfile.getAutoScaleUserId(); + final int destroyVmGraceperiod = vmProfile.getDestroyVmGraceperiod(); - VirtualMachineTemplate template = _entityMgr.findById(VirtualMachineTemplate.class, templateId); + final VirtualMachineTemplate template = _entityMgr.findById(VirtualMachineTemplate.class, templateId); // Make sure a valid template ID was specified if (template == null) { throw new InvalidParameterValueException("Unable to use the given template."); @@ -305,14 +310,14 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale throw new InvalidParameterValueException("Destroy Vm Grace Period cannot be less than 0."); } - User user = _userDao.findById(autoscaleUserId); + final User user = _userDao.findById(autoscaleUserId); if (user.getAccountId() != vmProfile.getAccountId()) { throw new InvalidParameterValueException("AutoScale User id does not belong to the same account"); } - String apiKey = user.getApiKey(); - String secretKey = user.getSecretKey(); - String csUrl = ApiServiceConfiguration.ApiServletPath.value(); + final String apiKey = user.getApiKey(); + final String secretKey = user.getSecretKey(); + final String csUrl = ApiServiceConfiguration.ApiServletPath.value(); if (apiKey == null) { throw new InvalidParameterValueException("apiKey for user: " + user.getUsername() + " is empty. Please generate it"); @@ -333,39 +338,40 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_AUTOSCALEVMPROFILE_CREATE, eventDescription = "creating autoscale vm profile", create = true) - public AutoScaleVmProfile createAutoScaleVmProfile(CreateAutoScaleVmProfileCmd cmd) { + public AutoScaleVmProfile createAutoScaleVmProfile(final CreateAutoScaleVmProfileCmd cmd) { - Account owner = _accountDao.findById(cmd.getAccountId()); - Account caller = CallContext.current().getCallingAccount(); + final Account owner = _accountDao.findById(cmd.getAccountId()); + final Account caller = CallContext.current().getCallingAccount(); _accountMgr.checkAccess(caller, null, true, owner); - long zoneId = cmd.getZoneId(); - long serviceOfferingId = cmd.getServiceOfferingId(); - long autoscaleUserId = cmd.getAutoscaleUserId(); + final long zoneId = cmd.getZoneId(); + final long serviceOfferingId = cmd.getServiceOfferingId(); + final long autoscaleUserId = cmd.getAutoscaleUserId(); - DataCenter zone = _entityMgr.findById(DataCenter.class, zoneId); + final DataCenter zone = _entityMgr.findById(DataCenter.class, zoneId); if (zone == null) { throw new InvalidParameterValueException("Unable to find zone by id"); } - ServiceOffering serviceOffering = _entityMgr.findById(ServiceOffering.class, serviceOfferingId); + final ServiceOffering serviceOffering = _entityMgr.findById(ServiceOffering.class, serviceOfferingId); if (serviceOffering == null) { throw new InvalidParameterValueException("Unable to find service offering by id"); } // validations - HashMap deployParams = cmd.getDeployParamMap(); + final HashMap deployParams = cmd.getDeployParamMap(); if (deployParams.containsKey("networks") && deployParams.get("networks").length() > 0) { throw new InvalidParameterValueException( "'networks' is not a valid parameter, network for an AutoScaled VM is chosen automatically. An autoscaled VM is deployed in the loadbalancer's network"); } + /* * Just for making sure the values are right in other deploy params. * For ex. if projectId is given as a string instead of an long value, this * will be throwing an error. */ - ApiDispatcher.processParameters(new DeployVMCmd(), deployParams); + dispatchChainFactory.getStandardDispatchChain().dispatch(new DispatchTask(new DeployVMCmd(), deployParams)); AutoScaleVmProfileVO profileVO = new AutoScaleVmProfileVO(cmd.getZoneId(), cmd.getDomainId(), cmd.getAccountId(), cmd.getServiceOfferingId(), cmd.getTemplateId(), cmd.getOtherDeployParams(), @@ -383,13 +389,13 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_AUTOSCALEVMPROFILE_UPDATE, eventDescription = "updating autoscale vm profile") - public AutoScaleVmProfile updateAutoScaleVmProfile(UpdateAutoScaleVmProfileCmd cmd) { - Long profileId = cmd.getId(); - Long templateId = cmd.getTemplateId(); - Long autoscaleUserId = cmd.getAutoscaleUserId(); - Map counterParamList = cmd.getCounterParamList(); + public AutoScaleVmProfile updateAutoScaleVmProfile(final UpdateAutoScaleVmProfileCmd cmd) { + final Long profileId = cmd.getId(); + final Long templateId = cmd.getTemplateId(); + final Long autoscaleUserId = cmd.getAutoscaleUserId(); + final Map counterParamList = cmd.getCounterParamList(); - Integer destroyVmGraceperiod = cmd.getDestroyVmGraceperiod(); + final Integer destroyVmGraceperiod = cmd.getDestroyVmGraceperiod(); AutoScaleVmProfileVO vmProfile = getEntityInDatabase(CallContext.current().getCallingAccount(), "Auto Scale Vm Profile", profileId, _autoScaleVmProfileDao); @@ -434,13 +440,13 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_AUTOSCALEVMPROFILE_DELETE, eventDescription = "deleting autoscale vm profile") - public boolean deleteAutoScaleVmProfile(long id) { + public boolean deleteAutoScaleVmProfile(final long id) { /* Check if entity is in database */ getEntityInDatabase(CallContext.current().getCallingAccount(), "AutoScale Vm Profile", id, _autoScaleVmProfileDao); if (_autoScaleVmGroupDao.isProfileInUse(id)) { throw new InvalidParameterValueException("Cannot delete AutoScale Vm Profile when it is in use by one more vm groups"); } - boolean success = _autoScaleVmProfileDao.remove(id); + final boolean success = _autoScaleVmProfileDao.remove(id); if (success) { s_logger.info("Successfully deleted AutoScale Vm Profile with Id: " + id); } @@ -456,8 +462,8 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale Long zoneId = cmd.getZoneId(); Boolean display = cmd.getDisplay(); - SearchWrapper searchWrapper = new SearchWrapper(_autoScaleVmProfileDao, AutoScaleVmProfileVO.class, cmd, cmd.getId()); - SearchBuilder sb = searchWrapper.getSearchBuilder(); + final SearchWrapper searchWrapper = new SearchWrapper(_autoScaleVmProfileDao, AutoScaleVmProfileVO.class, cmd, cmd.getId()); + final SearchBuilder sb = searchWrapper.getSearchBuilder(); sb.and("id", sb.entity().getId(), SearchCriteria.Op.EQ); sb.and("templateId", sb.entity().getTemplateId(), SearchCriteria.Op.EQ); @@ -507,19 +513,19 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale return Transaction.execute(new TransactionCallback() { @Override - public AutoScalePolicyVO doInTransaction(TransactionStatus status) { - AutoScalePolicyVO autoScalePolicyVO = _autoScalePolicyDao.persist(autoScalePolicyVOFinal); + public AutoScalePolicyVO doInTransaction(final TransactionStatus status) { + final AutoScalePolicyVO autoScalePolicyVO = _autoScalePolicyDao.persist(autoScalePolicyVOFinal); if (conditionIds != null) { - SearchBuilder conditionsSearch = _conditionDao.createSearchBuilder(); + final SearchBuilder conditionsSearch = _conditionDao.createSearchBuilder(); conditionsSearch.and("ids", conditionsSearch.entity().getId(), Op.IN); conditionsSearch.done(); - SearchCriteria sc = conditionsSearch.create(); + final SearchCriteria sc = conditionsSearch.create(); sc.setParameters("ids", conditionIds.toArray(new Object[0])); - List conditions = _conditionDao.search(sc, null); + final List conditions = _conditionDao.search(sc, null); - ControlledEntity[] sameOwnerEntities = conditions.toArray(new ControlledEntity[conditions.size() + 1]); + final ControlledEntity[] sameOwnerEntities = conditions.toArray(new ControlledEntity[conditions.size() + 1]); sameOwnerEntities[sameOwnerEntities.length - 1] = autoScalePolicyVO; _accountMgr.checkAccess(CallContext.current().getCallingAccount(), null, true, sameOwnerEntities); @@ -528,8 +534,8 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale throw new InvalidParameterValueException("Unable to find the condition specified"); } - ArrayList counterIds = new ArrayList(); - for (ConditionVO condition : conditions) { + final ArrayList counterIds = new ArrayList(); + for (final ConditionVO condition : conditions) { if (counterIds.contains(condition.getCounterid())) { throw new InvalidParameterValueException( "atleast two conditions in the conditionids have the same counter. It is not right to apply two different conditions for the same counter"); @@ -540,8 +546,8 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale /* For update case remove the existing mappings and create fresh ones */ _autoScalePolicyConditionMapDao.removeByAutoScalePolicyId(autoScalePolicyVO.getId()); - for (Long conditionId : conditionIds) { - AutoScalePolicyConditionMapVO policyConditionMapVO = new AutoScalePolicyConditionMapVO(autoScalePolicyVO.getId(), conditionId); + for (final Long conditionId : conditionIds) { + final AutoScalePolicyConditionMapVO policyConditionMapVO = new AutoScalePolicyConditionMapVO(autoScalePolicyVO.getId(), conditionId); _autoScalePolicyConditionMapDao.persist(policyConditionMapVO); } } @@ -553,9 +559,9 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_AUTOSCALEPOLICY_CREATE, eventDescription = "creating autoscale policy", create = true) - public AutoScalePolicy createAutoScalePolicy(CreateAutoScalePolicyCmd cmd) { + public AutoScalePolicy createAutoScalePolicy(final CreateAutoScalePolicyCmd cmd) { - int duration = cmd.getDuration(); + final int duration = cmd.getDuration(); Integer quietTime = cmd.getQuietTime(); String action = cmd.getAction(); @@ -588,7 +594,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale return Transaction.execute(new TransactionCallback() { @Override - public Boolean doInTransaction(TransactionStatus status) { + public Boolean doInTransaction(final TransactionStatus status) { boolean success = true; success = _autoScalePolicyDao.remove(id); if (!success) { @@ -607,11 +613,11 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale }); } - public void checkCallerAccess(String accountName, Long domainId) { - Account caller = CallContext.current().getCallingAccount(); - Account owner = _accountDao.findActiveAccount(accountName, domainId); + public void checkCallerAccess(final String accountName, final Long domainId) { + final Account caller = CallContext.current().getCallingAccount(); + final Account owner = _accountDao.findActiveAccount(accountName, domainId); if (owner == null) { - List idList = new ArrayList(); + final List idList = new ArrayList(); idList.add(ApiDBUtils.findDomainById(domainId).getUuid()); throw new InvalidParameterValueException("Unable to find account " + accountName + " in domain with specifed domainId"); } @@ -628,23 +634,23 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale ListProjectResourcesCriteria listProjectResourcesCriteria; Filter searchFilter; - public SearchWrapper(GenericDao dao, Class entityClass, BaseListAccountResourcesCmd cmd, Long id) { + public SearchWrapper(final GenericDao dao, final Class entityClass, final BaseListAccountResourcesCmd cmd, final Long id) { this.dao = dao; this.searchBuilder = dao.createSearchBuilder(); domainId = cmd.getDomainId(); - String accountName = cmd.getAccountName(); + final String accountName = cmd.getAccountName(); isRecursive = cmd.isRecursive(); - boolean listAll = cmd.listAll(); - long startIndex = cmd.getStartIndex(); - long pageSizeVal = cmd.getPageSizeVal(); - Account caller = CallContext.current().getCallingAccount(); + final boolean listAll = cmd.listAll(); + final long startIndex = cmd.getStartIndex(); + final long pageSizeVal = cmd.getPageSizeVal(); + final Account caller = CallContext.current().getCallingAccount(); - Ternary domainIdRecursiveListProject = + final Ternary domainIdRecursiveListProject = new Ternary(domainId, isRecursive, null); _accountMgr.buildACLSearchParameters(caller, id, accountName, null, permittedAccounts, domainIdRecursiveListProject, listAll, false); domainId = domainIdRecursiveListProject.first(); isRecursive = domainIdRecursiveListProject.second(); - ListProjectResourcesCriteria listProjectResourcesCriteria = domainIdRecursiveListProject.third(); + final ListProjectResourcesCriteria listProjectResourcesCriteria = domainIdRecursiveListProject.third(); _accountMgr.buildACLSearchBuilder(searchBuilder, domainId, isRecursive, permittedAccounts, listProjectResourcesCriteria); searchFilter = new Filter(entityClass, "id", false, startIndex, pageSizeVal); } @@ -665,30 +671,30 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } @Override - public List listAutoScalePolicies(ListAutoScalePoliciesCmd cmd) { - SearchWrapper searchWrapper = new SearchWrapper(_autoScalePolicyDao, AutoScalePolicyVO.class, cmd, cmd.getId()); - SearchBuilder sb = searchWrapper.getSearchBuilder(); - Long id = cmd.getId(); - Long conditionId = cmd.getConditionId(); - String action = cmd.getAction(); - Long vmGroupId = cmd.getVmGroupId(); + public List listAutoScalePolicies(final ListAutoScalePoliciesCmd cmd) { + final SearchWrapper searchWrapper = new SearchWrapper(_autoScalePolicyDao, AutoScalePolicyVO.class, cmd, cmd.getId()); + final SearchBuilder sb = searchWrapper.getSearchBuilder(); + final Long id = cmd.getId(); + final Long conditionId = cmd.getConditionId(); + final String action = cmd.getAction(); + final Long vmGroupId = cmd.getVmGroupId(); sb.and("id", sb.entity().getId(), SearchCriteria.Op.EQ); sb.and("action", sb.entity().getAction(), SearchCriteria.Op.EQ); if (conditionId != null) { - SearchBuilder asPolicyConditionSearch = _autoScalePolicyConditionMapDao.createSearchBuilder(); + final SearchBuilder asPolicyConditionSearch = _autoScalePolicyConditionMapDao.createSearchBuilder(); asPolicyConditionSearch.and("conditionId", asPolicyConditionSearch.entity().getConditionId(), SearchCriteria.Op.EQ); sb.join("asPolicyConditionSearch", asPolicyConditionSearch, sb.entity().getId(), asPolicyConditionSearch.entity().getPolicyId(), JoinBuilder.JoinType.INNER); } if (vmGroupId != null) { - SearchBuilder asVmGroupPolicySearch = _autoScaleVmGroupPolicyMapDao.createSearchBuilder(); + final SearchBuilder asVmGroupPolicySearch = _autoScaleVmGroupPolicyMapDao.createSearchBuilder(); asVmGroupPolicySearch.and("vmGroupId", asVmGroupPolicySearch.entity().getVmGroupId(), SearchCriteria.Op.EQ); sb.join("asVmGroupPolicySearch", asVmGroupPolicySearch, sb.entity().getId(), asVmGroupPolicySearch.entity().getPolicyId(), JoinBuilder.JoinType.INNER); } - SearchCriteria sc = searchWrapper.buildSearchCriteria(); + final SearchCriteria sc = searchWrapper.buildSearchCriteria(); if (id != null) { sc.setParameters("id", id); @@ -711,11 +717,11 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_AUTOSCALEPOLICY_UPDATE, eventDescription = "updating autoscale policy") - public AutoScalePolicy updateAutoScalePolicy(UpdateAutoScalePolicyCmd cmd) { - Long policyId = cmd.getId(); - Integer duration = cmd.getDuration(); - Integer quietTime = cmd.getQuietTime(); - List conditionIds = cmd.getConditionIds(); + public AutoScalePolicy updateAutoScalePolicy(final UpdateAutoScalePolicyCmd cmd) { + final Long policyId = cmd.getId(); + final Integer duration = cmd.getDuration(); + final Integer quietTime = cmd.getQuietTime(); + final List conditionIds = cmd.getConditionIds(); AutoScalePolicyVO policy = getEntityInDatabase(CallContext.current().getCallingAccount(), "Auto Scale Policy", policyId, _autoScalePolicyDao); if (duration != null) { @@ -726,9 +732,9 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale policy.setQuietTime(quietTime); } - List vmGroupPolicyList = _autoScaleVmGroupPolicyMapDao.listByPolicyId(policyId); - for (AutoScaleVmGroupPolicyMapVO vmGroupPolicy : vmGroupPolicyList) { - AutoScaleVmGroupVO vmGroupVO = _autoScaleVmGroupDao.findById(vmGroupPolicy.getVmGroupId()); + final List vmGroupPolicyList = _autoScaleVmGroupPolicyMapDao.listByPolicyId(policyId); + for (final AutoScaleVmGroupPolicyMapVO vmGroupPolicy : vmGroupPolicyList) { + final AutoScaleVmGroupVO vmGroupVO = _autoScaleVmGroupDao.findById(vmGroupPolicy.getVmGroupId()); if (vmGroupVO == null) { s_logger.warn("Stale database entry! There is an entry in VmGroupPolicyMap but the vmGroup is missing:" + vmGroupPolicy.getVmGroupId()); @@ -750,9 +756,9 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_AUTOSCALEVMGROUP_CREATE, eventDescription = "creating autoscale vm group", create = true) - public AutoScaleVmGroup createAutoScaleVmGroup(CreateAutoScaleVmGroupCmd cmd) { - int minMembers = cmd.getMinMembers(); - int maxMembers = cmd.getMaxMembers(); + public AutoScaleVmGroup createAutoScaleVmGroup(final CreateAutoScaleVmGroupCmd cmd) { + final int minMembers = cmd.getMinMembers(); + final int maxMembers = cmd.getMaxMembers(); Integer interval = cmd.getInterval(); Boolean forDisplay = cmd.getDisplay(); @@ -760,9 +766,9 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale interval = NetUtils.DEFAULT_AUTOSCALE_POLICY_INTERVAL_TIME; } - LoadBalancerVO loadBalancer = getEntityInDatabase(CallContext.current().getCallingAccount(), ApiConstants.LBID, cmd.getLbRuleId(), _lbDao); + final LoadBalancerVO loadBalancer = getEntityInDatabase(CallContext.current().getCallingAccount(), ApiConstants.LBID, cmd.getLbRuleId(), _lbDao); - Long zoneId = _ipAddressDao.findById(loadBalancer.getSourceIpAddressId()).getDataCenterId(); + final Long zoneId = _ipAddressDao.findById(loadBalancer.getSourceIpAddressId()).getDataCenterId(); if (_autoScaleVmGroupDao.isAutoScaleLoadBalancer(loadBalancer.getId())) { throw new InvalidParameterValueException("an AutoScaleVmGroup is already attached to the lb rule, the existing vm group has to be first deleted"); @@ -787,23 +793,23 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } @Override - public boolean configureAutoScaleVmGroup(CreateAutoScaleVmGroupCmd cmd) throws ResourceUnavailableException { + public boolean configureAutoScaleVmGroup(final CreateAutoScaleVmGroupCmd cmd) throws ResourceUnavailableException { return configureAutoScaleVmGroup(cmd.getEntityId(), AutoScaleVmGroup.State_New); } - public boolean isLoadBalancerBasedAutoScaleVmGroup(AutoScaleVmGroup vmGroup) { + public boolean isLoadBalancerBasedAutoScaleVmGroup(final AutoScaleVmGroup vmGroup) { return vmGroup.getLoadBalancerId() != null; } - private boolean configureAutoScaleVmGroup(long vmGroupid, String currentState) throws ResourceUnavailableException { - AutoScaleVmGroup vmGroup = _autoScaleVmGroupDao.findById(vmGroupid); + private boolean configureAutoScaleVmGroup(final long vmGroupid, final String currentState) throws ResourceUnavailableException { + final AutoScaleVmGroup vmGroup = _autoScaleVmGroupDao.findById(vmGroupid); if (isLoadBalancerBasedAutoScaleVmGroup(vmGroup)) { try { return _lbRulesMgr.configureLbAutoScaleVmGroup(vmGroupid, currentState); - } catch (ResourceUnavailableException re) { + } catch (final ResourceUnavailableException re) { throw re; - } catch (Exception e) { + } catch (final Exception e) { s_logger.warn("Exception during configureLbAutoScaleVmGroup in lb rules manager", e); return false; } @@ -817,20 +823,20 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @DB @ActionEvent(eventType = EventTypes.EVENT_AUTOSCALEVMGROUP_DELETE, eventDescription = "deleting autoscale vm group") public boolean deleteAutoScaleVmGroup(final long id) { - AutoScaleVmGroupVO autoScaleVmGroupVO = getEntityInDatabase(CallContext.current().getCallingAccount(), "AutoScale Vm Group", id, _autoScaleVmGroupDao); + final AutoScaleVmGroupVO autoScaleVmGroupVO = getEntityInDatabase(CallContext.current().getCallingAccount(), "AutoScale Vm Group", id, _autoScaleVmGroupDao); if (autoScaleVmGroupVO.getState().equals(AutoScaleVmGroup.State_New)) { /* This condition is for handling failures during creation command */ return _autoScaleVmGroupDao.remove(id); } - String bakupState = autoScaleVmGroupVO.getState(); + final String bakupState = autoScaleVmGroupVO.getState(); autoScaleVmGroupVO.setState(AutoScaleVmGroup.State_Revoke); _autoScaleVmGroupDao.persist(autoScaleVmGroupVO); boolean success = false; try { success = configureAutoScaleVmGroup(id, bakupState); - } catch (ResourceUnavailableException e) { + } catch (final ResourceUnavailableException e) { autoScaleVmGroupVO.setState(bakupState); _autoScaleVmGroupDao.persist(autoScaleVmGroupVO); } finally { @@ -842,7 +848,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale return Transaction.execute(new TransactionCallback() { @Override - public Boolean doInTransaction(TransactionStatus status) { + public Boolean doInTransaction(final TransactionStatus status) { boolean success = _autoScaleVmGroupDao.remove(id); if (!success) { @@ -872,8 +878,8 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale Long zoneId = cmd.getZoneId(); Boolean forDisplay = cmd.getDisplay(); - SearchWrapper searchWrapper = new SearchWrapper(_autoScaleVmGroupDao, AutoScaleVmGroupVO.class, cmd, cmd.getId()); - SearchBuilder sb = searchWrapper.getSearchBuilder(); + final SearchWrapper searchWrapper = new SearchWrapper(_autoScaleVmGroupDao, AutoScaleVmGroupVO.class, cmd, cmd.getId()); + final SearchBuilder sb = searchWrapper.getSearchBuilder(); sb.and("id", sb.entity().getId(), SearchCriteria.Op.EQ); sb.and("loadBalancerId", sb.entity().getLoadBalancerId(), SearchCriteria.Op.EQ); @@ -882,12 +888,12 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale sb.and("display", sb.entity().isDisplay(), SearchCriteria.Op.EQ); if (policyId != null) { - SearchBuilder asVmGroupPolicySearch = _autoScaleVmGroupPolicyMapDao.createSearchBuilder(); + final SearchBuilder asVmGroupPolicySearch = _autoScaleVmGroupPolicyMapDao.createSearchBuilder(); asVmGroupPolicySearch.and("policyId", asVmGroupPolicySearch.entity().getPolicyId(), SearchCriteria.Op.EQ); sb.join("asVmGroupPolicySearch", asVmGroupPolicySearch, sb.entity().getId(), asVmGroupPolicySearch.entity().getVmGroupId(), JoinBuilder.JoinType.INNER); } - SearchCriteria sc = searchWrapper.buildSearchCriteria(); + final SearchCriteria sc = searchWrapper.buildSearchCriteria(); if (id != null) { sc.setParameters("id", id); } @@ -912,14 +918,14 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @DB protected AutoScaleVmGroupVO checkValidityAndPersist(final AutoScaleVmGroupVO vmGroup, final List passedScaleUpPolicyIds, final List passedScaleDownPolicyIds) { - int minMembers = vmGroup.getMinMembers(); - int maxMembers = vmGroup.getMaxMembers(); - int interval = vmGroup.getInterval(); - List counters = new ArrayList(); - List policies = new ArrayList(); + final int minMembers = vmGroup.getMinMembers(); + final int maxMembers = vmGroup.getMaxMembers(); + final int interval = vmGroup.getInterval(); + final List counters = new ArrayList(); + final List policies = new ArrayList(); final List policyIds = new ArrayList(); - List currentScaleUpPolicyIds = new ArrayList(); - List currentScaleDownPolicyIds = new ArrayList(); + final List currentScaleUpPolicyIds = new ArrayList(); + final List currentScaleDownPolicyIds = new ArrayList(); if (vmGroup.getCreated() != null) { ApiDBUtils.getAutoScaleVmGroupPolicyIds(vmGroup.getId(), currentScaleUpPolicyIds, currentScaleDownPolicyIds); } @@ -958,26 +964,26 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale getAutoScalePolicies("scaledownpolicyid", currentScaleDownPolicyIds, counters, interval, false); policyIds.addAll(currentScaleDownPolicyIds); } - AutoScaleVmProfileVO profileVO = + final AutoScaleVmProfileVO profileVO = getEntityInDatabase(CallContext.current().getCallingAccount(), ApiConstants.VMPROFILE_ID, vmGroup.getProfileId(), _autoScaleVmProfileDao); - LoadBalancerVO loadBalancer = getEntityInDatabase(CallContext.current().getCallingAccount(), ApiConstants.LBID, vmGroup.getLoadBalancerId(), _lbDao); + final LoadBalancerVO loadBalancer = getEntityInDatabase(CallContext.current().getCallingAccount(), ApiConstants.LBID, vmGroup.getLoadBalancerId(), _lbDao); validateAutoScaleCounters(loadBalancer.getNetworkId(), counters, profileVO.getCounterParams()); - ControlledEntity[] sameOwnerEntities = policies.toArray(new ControlledEntity[policies.size() + 2]); + final ControlledEntity[] sameOwnerEntities = policies.toArray(new ControlledEntity[policies.size() + 2]); sameOwnerEntities[sameOwnerEntities.length - 2] = loadBalancer; sameOwnerEntities[sameOwnerEntities.length - 1] = profileVO; _accountMgr.checkAccess(CallContext.current().getCallingAccount(), null, true, sameOwnerEntities); return Transaction.execute(new TransactionCallback() { @Override - public AutoScaleVmGroupVO doInTransaction(TransactionStatus status) { - AutoScaleVmGroupVO vmGroupNew = _autoScaleVmGroupDao.persist(vmGroup); + public AutoScaleVmGroupVO doInTransaction(final TransactionStatus status) { + final AutoScaleVmGroupVO vmGroupNew = _autoScaleVmGroupDao.persist(vmGroup); if (passedScaleUpPolicyIds != null || passedScaleDownPolicyIds != null) { _autoScaleVmGroupPolicyMapDao.removeByGroupId(vmGroupNew.getId()); - for (Long policyId : policyIds) { + for (final Long policyId : policyIds) { _autoScaleVmGroupPolicyMapDao.persist(new AutoScaleVmGroupPolicyMapVO(vmGroupNew.getId(), policyId)); } } @@ -990,15 +996,15 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_AUTOSCALEVMGROUP_UPDATE, eventDescription = "updating autoscale vm group") - public AutoScaleVmGroup updateAutoScaleVmGroup(UpdateAutoScaleVmGroupCmd cmd) { - Long vmGroupId = cmd.getId(); - Integer minMembers = cmd.getMinMembers(); - Integer maxMembers = cmd.getMaxMembers(); - Integer interval = cmd.getInterval(); - Boolean forDisplay = cmd.getDisplay(); + public AutoScaleVmGroup updateAutoScaleVmGroup(final UpdateAutoScaleVmGroupCmd cmd) { + final Long vmGroupId = cmd.getId(); + final Integer minMembers = cmd.getMinMembers(); + final Integer maxMembers = cmd.getMaxMembers(); + final Integer interval = cmd.getInterval(); + final Boolean forDisplay = cmd.getDisplay(); - List scaleUpPolicyIds = cmd.getScaleUpPolicyIds(); - List scaleDownPolicyIds = cmd.getScaleDownPolicyIds(); + final List scaleUpPolicyIds = cmd.getScaleUpPolicyIds(); + final List scaleDownPolicyIds = cmd.getScaleDownPolicyIds(); AutoScaleVmGroupVO vmGroupVO = getEntityInDatabase(CallContext.current().getCallingAccount(), "AutoScale Vm Group", vmGroupId, _autoScaleVmGroupDao); @@ -1039,7 +1045,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @DB @ActionEvent(eventType = EventTypes.EVENT_AUTOSCALEVMGROUP_ENABLE, eventDescription = "enabling autoscale vm group") - public AutoScaleVmGroup enableAutoScaleVmGroup(Long id) { + public AutoScaleVmGroup enableAutoScaleVmGroup(final Long id) { AutoScaleVmGroupVO vmGroup = getEntityInDatabase(CallContext.current().getCallingAccount(), "AutoScale Vm Group", id, _autoScaleVmGroupDao); boolean success = false; if (!vmGroup.getState().equals(AutoScaleVmGroup.State_Disabled)) { @@ -1050,7 +1056,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale vmGroup.setState(AutoScaleVmGroup.State_Enabled); vmGroup = _autoScaleVmGroupDao.persist(vmGroup); success = configureAutoScaleVmGroup(id, AutoScaleVmGroup.State_Disabled); - } catch (ResourceUnavailableException e) { + } catch (final ResourceUnavailableException e) { vmGroup.setState(AutoScaleVmGroup.State_Disabled); _autoScaleVmGroupDao.persist(vmGroup); } finally { @@ -1066,7 +1072,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_AUTOSCALEVMGROUP_DISABLE, eventDescription = "disabling autoscale vm group") @DB - public AutoScaleVmGroup disableAutoScaleVmGroup(Long id) { + public AutoScaleVmGroup disableAutoScaleVmGroup(final Long id) { AutoScaleVmGroupVO vmGroup = getEntityInDatabase(CallContext.current().getCallingAccount(), "AutoScale Vm Group", id, _autoScaleVmGroupDao); boolean success = false; if (!vmGroup.getState().equals(AutoScaleVmGroup.State_Enabled)) { @@ -1077,7 +1083,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale vmGroup.setState(AutoScaleVmGroup.State_Disabled); vmGroup = _autoScaleVmGroupDao.persist(vmGroup); success = configureAutoScaleVmGroup(id, AutoScaleVmGroup.State_Enabled); - } catch (ResourceUnavailableException e) { + } catch (final ResourceUnavailableException e) { vmGroup.setState(AutoScaleVmGroup.State_Enabled); _autoScaleVmGroupDao.persist(vmGroup); } finally { @@ -1093,14 +1099,14 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_COUNTER_CREATE, eventDescription = "Counter", create = true) @DB - public Counter createCounter(CreateCounterCmd cmd) { - String source = cmd.getSource().toLowerCase(); - String name = cmd.getName(); + public Counter createCounter(final CreateCounterCmd cmd) { + final String source = cmd.getSource().toLowerCase(); + final String name = cmd.getName(); Counter.Source src; // Validate Source try { src = Counter.Source.valueOf(source); - } catch (Exception ex) { + } catch (final Exception ex) { throw new InvalidParameterValueException("The Source " + source + " does not exist; Unable to create Counter"); } @@ -1115,21 +1121,21 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_CONDITION_CREATE, eventDescription = "Condition", create = true) - public Condition createCondition(CreateConditionCmd cmd) { + public Condition createCondition(final CreateConditionCmd cmd) { checkCallerAccess(cmd.getAccountName(), cmd.getDomainId()); - String opr = cmd.getRelationalOperator().toUpperCase(); - long cid = cmd.getCounterId(); - long threshold = cmd.getThreshold(); + final String opr = cmd.getRelationalOperator().toUpperCase(); + final long cid = cmd.getCounterId(); + final long threshold = cmd.getThreshold(); Condition.Operator op; // Validate Relational Operator try { op = Condition.Operator.valueOf(opr); - } catch (IllegalArgumentException ex) { + } catch (final IllegalArgumentException ex) { throw new InvalidParameterValueException("The Operator " + opr + " does not exist; Unable to create Condition."); } // TODO - Validate threshold - CounterVO counter = _counterDao.findById(cid); + final CounterVO counter = _counterDao.findById(cid); if (counter == null) { throw new InvalidParameterValueException("Unable to find counter"); @@ -1144,29 +1150,29 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } @Override - public List listCounters(ListCountersCmd cmd) { - String name = cmd.getName(); - Long id = cmd.getId(); + public List listCounters(final ListCountersCmd cmd) { + final String name = cmd.getName(); + final Long id = cmd.getId(); String source = cmd.getSource(); if (source != null) source = source.toLowerCase(); - Filter searchFilter = new Filter(CounterVO.class, "created", false, cmd.getStartIndex(), cmd.getPageSizeVal()); + final Filter searchFilter = new Filter(CounterVO.class, "created", false, cmd.getStartIndex(), cmd.getPageSizeVal()); - List counters = _counterDao.listCounters(id, name, source, cmd.getKeyword(), searchFilter); + final List counters = _counterDao.listCounters(id, name, source, cmd.getKeyword(), searchFilter); return counters; } @Override - public List listConditions(ListConditionsCmd cmd) { - Long id = cmd.getId(); - Long counterId = cmd.getCounterId(); - Long policyId = cmd.getPolicyId(); - SearchWrapper searchWrapper = new SearchWrapper(_conditionDao, ConditionVO.class, cmd, cmd.getId()); - SearchBuilder sb = searchWrapper.getSearchBuilder(); + public List listConditions(final ListConditionsCmd cmd) { + final Long id = cmd.getId(); + final Long counterId = cmd.getCounterId(); + final Long policyId = cmd.getPolicyId(); + final SearchWrapper searchWrapper = new SearchWrapper(_conditionDao, ConditionVO.class, cmd, cmd.getId()); + final SearchBuilder sb = searchWrapper.getSearchBuilder(); if (policyId != null) { - SearchBuilder asPolicyConditionSearch = _autoScalePolicyConditionMapDao.createSearchBuilder(); + final SearchBuilder asPolicyConditionSearch = _autoScalePolicyConditionMapDao.createSearchBuilder(); asPolicyConditionSearch.and("policyId", asPolicyConditionSearch.entity().getPolicyId(), SearchCriteria.Op.EQ); sb.join("asPolicyConditionSearch", asPolicyConditionSearch, sb.entity().getId(), asPolicyConditionSearch.entity().getConditionId(), JoinBuilder.JoinType.INNER); @@ -1176,7 +1182,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale sb.and("counterId", sb.entity().getCounterid(), SearchCriteria.Op.EQ); // now set the SC criteria... - SearchCriteria sc = searchWrapper.buildSearchCriteria(); + final SearchCriteria sc = searchWrapper.buildSearchCriteria(); if (id != null) { sc.setParameters("id", id); @@ -1195,22 +1201,22 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_COUNTER_DELETE, eventDescription = "counter") - public boolean deleteCounter(long counterId) throws ResourceInUseException { + public boolean deleteCounter(final long counterId) throws ResourceInUseException { // Verify Counter id - CounterVO counter = _counterDao.findById(counterId); + final CounterVO counter = _counterDao.findById(counterId); if (counter == null) { throw new InvalidParameterValueException("Unable to find Counter"); } // Verify if it is used in any Condition - ConditionVO condition = _conditionDao.findByCounterId(counterId); + final ConditionVO condition = _conditionDao.findByCounterId(counterId); if (condition != null) { s_logger.info("Cannot delete counter " + counter.getName() + " as it is being used in a condition."); throw new ResourceInUseException("Counter is in use."); } - boolean success = _counterDao.remove(counterId); + final boolean success = _counterDao.remove(counterId); if (success) { s_logger.info("Successfully deleted counter with Id: " + counterId); } @@ -1220,9 +1226,9 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override @ActionEvent(eventType = EventTypes.EVENT_CONDITION_DELETE, eventDescription = "condition") - public boolean deleteCondition(long conditionId) throws ResourceInUseException { + public boolean deleteCondition(final long conditionId) throws ResourceInUseException { /* Check if entity is in database */ - ConditionVO condition = getEntityInDatabase(CallContext.current().getCallingAccount(), "Condition", conditionId, _conditionDao); + final ConditionVO condition = getEntityInDatabase(CallContext.current().getCallingAccount(), "Condition", conditionId, _conditionDao); if (condition == null) { throw new InvalidParameterValueException("Unable to find Condition"); } @@ -1232,7 +1238,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale s_logger.info("Cannot delete condition " + conditionId + " as it is being used in a condition."); throw new ResourceInUseException("Cannot delete Condition when it is in use by one or more AutoScale Policies."); } - boolean success = _conditionDao.remove(conditionId); + final boolean success = _conditionDao.remove(conditionId); if (success) { s_logger.info("Successfully deleted condition " + condition.getId()); } @@ -1240,7 +1246,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } @Override - public void cleanUpAutoScaleResources(Long accountId) { + public void cleanUpAutoScaleResources(final Long accountId) { // cleans Autoscale VmProfiles, AutoScale Policies and Conditions belonging to an account int count = 0; count = _autoScaleVmProfileDao.removeByAccountId(accountId); @@ -1257,10 +1263,10 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } } - private boolean checkConditionUp(AutoScaleVmGroupVO asGroup, Integer numVm) { + private boolean checkConditionUp(final AutoScaleVmGroupVO asGroup, final Integer numVm) { // check maximum - Integer currentVM = _autoScaleVmGroupVmMapDao.countByGroup(asGroup.getId()); - Integer maxVm = asGroup.getMaxMembers(); + final Integer currentVM = _autoScaleVmGroupVmMapDao.countByGroup(asGroup.getId()); + final Integer maxVm = asGroup.getMaxMembers(); if (currentVM + numVm > maxVm) { s_logger.warn("number of VM will greater than the maximum in this group if scaling up, so do nothing more"); return false; @@ -1268,9 +1274,9 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale return true; } - private boolean checkConditionDown(AutoScaleVmGroupVO asGroup) { - Integer currentVM = _autoScaleVmGroupVmMapDao.countByGroup(asGroup.getId()); - Integer minVm = asGroup.getMinMembers(); + private boolean checkConditionDown(final AutoScaleVmGroupVO asGroup) { + final Integer currentVM = _autoScaleVmGroupVmMapDao.countByGroup(asGroup.getId()); + final Integer minVm = asGroup.getMinMembers(); if (currentVM - 1 < minVm) { s_logger.warn("number of VM will less than the minimum in this group if scaling down, so do nothing more"); return false; @@ -1278,29 +1284,29 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale return true; } - private long createNewVM(AutoScaleVmGroupVO asGroup) { - AutoScaleVmProfileVO profileVo = _autoScaleVmProfileDao.findById(asGroup.getProfileId()); - long templateId = profileVo.getTemplateId(); - long serviceOfferingId = profileVo.getServiceOfferingId(); + private long createNewVM(final AutoScaleVmGroupVO asGroup) { + final AutoScaleVmProfileVO profileVo = _autoScaleVmProfileDao.findById(asGroup.getProfileId()); + final long templateId = profileVo.getTemplateId(); + final long serviceOfferingId = profileVo.getServiceOfferingId(); if (templateId == -1) { return -1; } // create new VM into DB try { //Verify that all objects exist before passing them to the service - Account owner = _accountService.getActiveAccountById(profileVo.getAccountId()); + final Account owner = _accountService.getActiveAccountById(profileVo.getAccountId()); - DataCenter zone = _entityMgr.findById(DataCenter.class, profileVo.getZoneId()); + final DataCenter zone = _entityMgr.findById(DataCenter.class, profileVo.getZoneId()); if (zone == null) { throw new InvalidParameterValueException("Unable to find zone by id=" + profileVo.getZoneId()); } - ServiceOffering serviceOffering = _entityMgr.findById(ServiceOffering.class, serviceOfferingId); + final ServiceOffering serviceOffering = _entityMgr.findById(ServiceOffering.class, serviceOfferingId); if (serviceOffering == null) { throw new InvalidParameterValueException("Unable to find service offering: " + serviceOfferingId); } - VirtualMachineTemplate template = _entityMgr.findById(VirtualMachineTemplate.class, templateId); + final VirtualMachineTemplate template = _entityMgr.findById(VirtualMachineTemplate.class, templateId); // Make sure a valid template ID was specified if (template == null) { throw new InvalidParameterValueException("Unable to use template " + templateId); @@ -1313,7 +1319,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } UserVm vm = null; - IpAddresses addrs = new IpAddresses(null, null); + final IpAddresses addrs = new IpAddresses(null, null); if (zone.getNetworkType() == NetworkType.Basic) { vm = _userVmService.createBasicSecurityGroupVirtualMachine(zone, serviceOffering, template, null, owner, "autoScaleVm-" + asGroup.getId() + "-" + getCurrentTimeStampString(), @@ -1339,41 +1345,41 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } else { return -1; } - } catch (InsufficientCapacityException ex) { + } catch (final InsufficientCapacityException ex) { s_logger.info(ex); s_logger.trace(ex.getMessage(), ex); throw new ServerApiException(ApiErrorCode.INSUFFICIENT_CAPACITY_ERROR, ex.getMessage()); - } catch (ResourceUnavailableException ex) { + } catch (final ResourceUnavailableException ex) { s_logger.warn("Exception: ", ex); throw new ServerApiException(ApiErrorCode.RESOURCE_UNAVAILABLE_ERROR, ex.getMessage()); - } catch (ConcurrentOperationException ex) { + } catch (final ConcurrentOperationException ex) { s_logger.warn("Exception: ", ex); throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, ex.getMessage()); - } catch (ResourceAllocationException ex) { + } catch (final ResourceAllocationException ex) { s_logger.warn("Exception: ", ex); throw new ServerApiException(ApiErrorCode.RESOURCE_ALLOCATION_ERROR, ex.getMessage()); } } private String getCurrentTimeStampString() { - Date current = new Date(); - SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss"); + final Date current = new Date(); + final SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmss"); return sdf.format(current); } - private boolean startNewVM(long vmId) { + private boolean startNewVM(final long vmId) { try { CallContext.current().setEventDetails("Vm Id: " + vmId); _userVmManager.startVirtualMachine(vmId, null, null); - } catch (ResourceUnavailableException ex) { + } catch (final ResourceUnavailableException ex) { s_logger.warn("Exception: ", ex); throw new ServerApiException(ApiErrorCode.RESOURCE_UNAVAILABLE_ERROR, ex.getMessage()); - } catch (ConcurrentOperationException ex) { + } catch (final ConcurrentOperationException ex) { s_logger.warn("Exception: ", ex); throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, ex.getMessage()); - } catch (InsufficientCapacityException ex) { - StringBuilder message = new StringBuilder(ex.getMessage()); + } catch (final InsufficientCapacityException ex) { + final StringBuilder message = new StringBuilder(ex.getMessage()); if (ex instanceof InsufficientServerCapacityException) { if (((InsufficientServerCapacityException)ex).isAffinityApplied()) { message.append(", Please check the affinity groups provided, there may not be sufficient capacity to follow them"); @@ -1386,14 +1392,14 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale return true; } - private boolean assignLBruleToNewVm(long vmId, AutoScaleVmGroupVO asGroup) { - List lstVmId = new ArrayList(); - long lbId = asGroup.getLoadBalancerId(); + private boolean assignLBruleToNewVm(final long vmId, final AutoScaleVmGroupVO asGroup) { + final List lstVmId = new ArrayList(); + final long lbId = asGroup.getLoadBalancerId(); - List LbVmMapVos = _lbVmMapDao.listByLoadBalancerId(lbId); + final List LbVmMapVos = _lbVmMapDao.listByLoadBalancerId(lbId); if ((LbVmMapVos != null) && (LbVmMapVos.size() > 0)) { - for (LoadBalancerVMMapVO LbVmMapVo : LbVmMapVos) { - long instanceId = LbVmMapVo.getInstanceId(); + for (final LoadBalancerVMMapVO LbVmMapVo : LbVmMapVos) { + final long instanceId = LbVmMapVo.getInstanceId(); if (instanceId == vmId) { s_logger.warn("the new VM is already mapped to LB rule. What's wrong?"); return true; @@ -1405,17 +1411,17 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } - private long removeLBrule(AutoScaleVmGroupVO asGroup) { - long lbId = asGroup.getLoadBalancerId(); + private long removeLBrule(final AutoScaleVmGroupVO asGroup) { + final long lbId = asGroup.getLoadBalancerId(); long instanceId = -1; - List LbVmMapVos = _lbVmMapDao.listByLoadBalancerId(lbId); + final List LbVmMapVos = _lbVmMapDao.listByLoadBalancerId(lbId); if ((LbVmMapVos != null) && (LbVmMapVos.size() > 0)) { - for (LoadBalancerVMMapVO LbVmMapVo : LbVmMapVos) { + for (final LoadBalancerVMMapVO LbVmMapVo : LbVmMapVos) { instanceId = LbVmMapVo.getInstanceId(); } } // take last VM out of the list - List lstVmId = new ArrayList(); + final List lstVmId = new ArrayList(); if (instanceId != -1) lstVmId.add(instanceId); if (_loadBalancingRulesService.removeFromLoadBalancer(lbId, lstVmId)) @@ -1425,8 +1431,8 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } @Override - public void doScaleUp(long groupId, Integer numVm) { - AutoScaleVmGroupVO asGroup = _autoScaleVmGroupDao.findById(groupId); + public void doScaleUp(final long groupId, final Integer numVm) { + final AutoScaleVmGroupVO asGroup = _autoScaleVmGroupDao.findById(groupId); if (asGroup == null) { s_logger.error("Can not find the groupid " + groupId + " for scaling up"); return; @@ -1435,7 +1441,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale return; } for (int i = 0; i < numVm; i++) { - long vmId = createNewVM(asGroup); + final long vmId = createNewVM(asGroup); if (vmId == -1) { s_logger.error("Can not deploy new VM for scaling up in the group " + asGroup.getId() + ". Waiting for next round"); @@ -1444,14 +1450,14 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale if (startNewVM(vmId)) { if (assignLBruleToNewVm(vmId, asGroup)) { // persist to DB - AutoScaleVmGroupVmMapVO GroupVmVO = new AutoScaleVmGroupVmMapVO( + final AutoScaleVmGroupVmMapVO GroupVmVO = new AutoScaleVmGroupVmMapVO( asGroup.getId(), vmId); _autoScaleVmGroupVmMapDao.persist(GroupVmVO); // update last_quiettime - List GroupPolicyVOs = _autoScaleVmGroupPolicyMapDao + final List GroupPolicyVOs = _autoScaleVmGroupPolicyMapDao .listByVmGroupId(groupId); - for (AutoScaleVmGroupPolicyMapVO GroupPolicyVO : GroupPolicyVOs) { - AutoScalePolicyVO vo = _autoScalePolicyDao + for (final AutoScaleVmGroupPolicyMapVO GroupPolicyVO : GroupPolicyVOs) { + final AutoScalePolicyVO vo = _autoScalePolicyDao .findById(GroupPolicyVO.getPolicyId()); if (vo.getAction().equals("scaleup")) { vo.setLastQuiteTime(new Date()); @@ -1473,7 +1479,7 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale @Override public void doScaleDown(final long groupId) { - AutoScaleVmGroupVO asGroup = _autoScaleVmGroupDao.findById(groupId); + final AutoScaleVmGroupVO asGroup = _autoScaleVmGroupDao.findById(groupId); if (asGroup == null) { s_logger.error("Can not find the groupid " + groupId + " for scaling up"); return; @@ -1483,14 +1489,14 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } final long vmId = removeLBrule(asGroup); if (vmId != -1) { - long profileId = asGroup.getProfileId(); + final long profileId = asGroup.getProfileId(); // update group-vm mapping _autoScaleVmGroupVmMapDao.remove(groupId, vmId); // update last_quiettime - List GroupPolicyVOs = _autoScaleVmGroupPolicyMapDao.listByVmGroupId(groupId); - for (AutoScaleVmGroupPolicyMapVO GroupPolicyVO : GroupPolicyVOs) { - AutoScalePolicyVO vo = _autoScalePolicyDao.findById(GroupPolicyVO.getPolicyId()); + final List GroupPolicyVOs = _autoScaleVmGroupPolicyMapDao.listByVmGroupId(groupId); + for (final AutoScaleVmGroupPolicyMapVO GroupPolicyVO : GroupPolicyVOs) { + final AutoScalePolicyVO vo = _autoScalePolicyDao.findById(GroupPolicyVO.getPolicyId()); if (vo.getAction().equals("scaledown")) { vo.setLastQuiteTime(new Date()); _autoScalePolicyDao.persist(vo); @@ -1499,8 +1505,8 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale } // get destroyvmgrace param - AutoScaleVmProfileVO asProfile = _autoScaleVmProfileDao.findById(profileId); - Integer destroyVmGracePeriod = asProfile.getDestroyVmGraceperiod(); + final AutoScaleVmProfileVO asProfile = _autoScaleVmProfileDao.findById(profileId); + final Integer destroyVmGracePeriod = asProfile.getDestroyVmGraceperiod(); if (destroyVmGracePeriod >= 0) { _executor.schedule(new Runnable() { @Override @@ -1509,9 +1515,9 @@ public class AutoScaleManagerImpl extends ManagerBase implements AutoScale _userVmManager.destroyVm(vmId); - } catch (ResourceUnavailableException e) { + } catch (final ResourceUnavailableException e) { e.printStackTrace(); - } catch (ConcurrentOperationException e) { + } catch (final ConcurrentOperationException e) { e.printStackTrace(); } } diff --git a/server/src/com/cloud/network/router/VirtualNetworkApplianceManagerImpl.java b/server/src/com/cloud/network/router/VirtualNetworkApplianceManagerImpl.java index 8486f06aaa7..3c99867fd01 100755 --- a/server/src/com/cloud/network/router/VirtualNetworkApplianceManagerImpl.java +++ b/server/src/com/cloud/network/router/VirtualNetworkApplianceManagerImpl.java @@ -105,7 +105,6 @@ import com.cloud.agent.api.to.StaticNatRuleTO; import com.cloud.agent.manager.Commands; import com.cloud.alert.AlertManager; import com.cloud.api.ApiAsyncJobDispatcher; -import com.cloud.api.ApiDispatcher; import com.cloud.api.ApiGsonHelper; import com.cloud.cluster.ManagementServerHostVO; import com.cloud.cluster.dao.ManagementServerHostDao; @@ -4195,7 +4194,6 @@ public class VirtualNetworkApplianceManagerImpl extends ManagerBase implements V for(DomainRouterVO router: routers){ if(!checkRouterVersion(router)){ s_logger.debug("Upgrading template for router: "+router.getId()); - ApiDispatcher.getInstance(); Map params = new HashMap(); params.put("ctxUserId", "1"); params.put("ctxAccountId", "" + router.getAccountId()); diff --git a/server/src/com/cloud/storage/snapshot/SnapshotSchedulerImpl.java b/server/src/com/cloud/storage/snapshot/SnapshotSchedulerImpl.java index a85c0526e1f..447697f1005 100644 --- a/server/src/com/cloud/storage/snapshot/SnapshotSchedulerImpl.java +++ b/server/src/com/cloud/storage/snapshot/SnapshotSchedulerImpl.java @@ -82,6 +82,8 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu protected VolumeDao _volsDao; @Inject protected ConfigurationDao _configDao; + @Inject + protected ApiDispatcher _dispatcher; protected AsyncJobDispatcher _asyncDispatcher; @@ -95,21 +97,21 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu return _asyncDispatcher; } - public void setAsyncJobDispatcher(AsyncJobDispatcher dispatcher) { + public void setAsyncJobDispatcher(final AsyncJobDispatcher dispatcher) { _asyncDispatcher = dispatcher; } - private Date getNextScheduledTime(long policyId, Date currentTimestamp) { - SnapshotPolicyVO policy = _snapshotPolicyDao.findById(policyId); + private Date getNextScheduledTime(final long policyId, final Date currentTimestamp) { + final SnapshotPolicyVO policy = _snapshotPolicyDao.findById(policyId); Date nextTimestamp = null; if (policy != null) { - short intervalType = policy.getInterval(); - IntervalType type = DateUtil.getIntervalType(intervalType); - String schedule = policy.getSchedule(); - String timezone = policy.getTimezone(); + final short intervalType = policy.getInterval(); + final IntervalType type = DateUtil.getIntervalType(intervalType); + final String schedule = policy.getSchedule(); + final String timezone = policy.getTimezone(); nextTimestamp = DateUtil.getNextRunTime(type, schedule, timezone, currentTimestamp); - String currentTime = DateUtil.displayDateInTimezone(DateUtil.GMT_TIMEZONE, currentTimestamp); - String nextScheduledTime = DateUtil.displayDateInTimezone(DateUtil.GMT_TIMEZONE, nextTimestamp); + final String currentTime = DateUtil.displayDateInTimezone(DateUtil.GMT_TIMEZONE, currentTimestamp); + final String nextScheduledTime = DateUtil.displayDateInTimezone(DateUtil.GMT_TIMEZONE, nextTimestamp); s_logger.debug("Current time is " + currentTime + ". NextScheduledTime of policyId " + policyId + " is " + nextScheduledTime); } return nextTimestamp; @@ -119,7 +121,7 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu * {@inheritDoc} */ @Override - public void poll(Date currentTimestamp) { + public void poll(final Date currentTimestamp) { // We don't maintain the time. The timer task does. _currentTimestamp = currentTimestamp; @@ -151,12 +153,12 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu } private void checkStatusOfCurrentlyExecutingSnapshots() { - SearchCriteria sc = _snapshotScheduleDao.createSearchCriteria(); + final SearchCriteria sc = _snapshotScheduleDao.createSearchCriteria(); sc.addAnd("asyncJobId", SearchCriteria.Op.NNULL); - List snapshotSchedules = _snapshotScheduleDao.search(sc, null); - for (SnapshotScheduleVO snapshotSchedule : snapshotSchedules) { - Long asyncJobId = snapshotSchedule.getAsyncJobId(); - AsyncJobVO asyncJob = _asyncJobDao.findById(asyncJobId); + final List snapshotSchedules = _snapshotScheduleDao.search(sc, null); + for (final SnapshotScheduleVO snapshotSchedule : snapshotSchedules) { + final Long asyncJobId = snapshotSchedule.getAsyncJobId(); + final AsyncJobVO asyncJob = _asyncJobDao.findById(asyncJobId); switch (asyncJob.getStatus()) { case SUCCEEDED: // The snapshot has been successfully backed up. @@ -167,7 +169,7 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu break; case FAILED: // Check the snapshot status. - Long snapshotId = snapshotSchedule.getSnapshotId(); + final Long snapshotId = snapshotSchedule.getSnapshotId(); if (snapshotId == null) { // createSnapshotAsync exited, successfully or unsuccessfully, // even before creating a snapshot record @@ -175,7 +177,7 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu // Schedule the next snapshot. scheduleNextSnapshotJob(snapshotSchedule); } else { - SnapshotVO snapshot = _snapshotDao.findById(snapshotId); + final SnapshotVO snapshot = _snapshotDao.findById(snapshotId); if (snapshot == null || snapshot.getRemoved() != null) { // This snapshot has been deleted successfully from the primary storage // Again no cleanup needs to be done. @@ -219,16 +221,16 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu String displayTime = DateUtil.displayDateInTimezone(DateUtil.GMT_TIMEZONE, _currentTimestamp); s_logger.debug("Snapshot scheduler.poll is being called at " + displayTime); - List snapshotsToBeExecuted = _snapshotScheduleDao.getSchedulesToExecute(_currentTimestamp); + final List snapshotsToBeExecuted = _snapshotScheduleDao.getSchedulesToExecute(_currentTimestamp); s_logger.debug("Got " + snapshotsToBeExecuted.size() + " snapshots to be executed at " + displayTime); - for (SnapshotScheduleVO snapshotToBeExecuted : snapshotsToBeExecuted) { + for (final SnapshotScheduleVO snapshotToBeExecuted : snapshotsToBeExecuted) { SnapshotScheduleVO tmpSnapshotScheduleVO = null; - long snapshotScheId = snapshotToBeExecuted.getId(); - long policyId = snapshotToBeExecuted.getPolicyId(); - long volumeId = snapshotToBeExecuted.getVolumeId(); + final long snapshotScheId = snapshotToBeExecuted.getId(); + final long policyId = snapshotToBeExecuted.getPolicyId(); + final long volumeId = snapshotToBeExecuted.getVolumeId(); try { - VolumeVO volume = _volsDao.findById(volumeId); + final VolumeVO volume = _volsDao.findById(volumeId); if (volume.getPoolId() == null) { // this volume is not attached continue; @@ -237,26 +239,26 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu _snapshotScheduleDao.remove(snapshotToBeExecuted.getId()); } if (s_logger.isDebugEnabled()) { - Date scheduledTimestamp = snapshotToBeExecuted.getScheduledTimestamp(); + final Date scheduledTimestamp = snapshotToBeExecuted.getScheduledTimestamp(); displayTime = DateUtil.displayDateInTimezone(DateUtil.GMT_TIMEZONE, scheduledTimestamp); s_logger.debug("Scheduling 1 snapshot for volume " + volumeId + " for schedule id: " + snapshotToBeExecuted.getId() + " at " + displayTime); } tmpSnapshotScheduleVO = _snapshotScheduleDao.acquireInLockTable(snapshotScheId); - Long eventId = + final Long eventId = ActionEventUtils.onScheduledActionEvent(User.UID_SYSTEM, volume.getAccountId(), EventTypes.EVENT_SNAPSHOT_CREATE, "creating snapshot for volume Id:" + volumeId, true, 0); - Map params = new HashMap(); + final Map params = new HashMap(); params.put(ApiConstants.VOLUME_ID, "" + volumeId); params.put(ApiConstants.POLICY_ID, "" + policyId); params.put("ctxUserId", "1"); params.put("ctxAccountId", "" + volume.getAccountId()); params.put("ctxStartEventId", String.valueOf(eventId)); - CreateSnapshotCmd cmd = new CreateSnapshotCmd(); + final CreateSnapshotCmd cmd = new CreateSnapshotCmd(); ComponentContext.inject(cmd); - ApiDispatcher.getInstance().dispatchCreateCmd(cmd, params); + _dispatcher.dispatchCreateCmd(cmd, params); params.put("id", "" + cmd.getEntityId()); params.put("ctxStartEventId", "1"); @@ -265,11 +267,12 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu cmd.getInstanceType() != null ? cmd.getInstanceType().toString() : null); job.setDispatcher(_asyncDispatcher.getName()); - long jobId = _asyncMgr.submitAsyncJob(job); + final long jobId = _asyncMgr.submitAsyncJob(job); tmpSnapshotScheduleVO.setAsyncJobId(jobId); _snapshotScheduleDao.update(snapshotScheId, tmpSnapshotScheduleVO); - } catch (Exception e) { + } catch (final Exception e) { + // TODO Logging this exception is enough? s_logger.warn("Scheduling snapshot failed due to " + e.toString()); } finally { if (tmpSnapshotScheduleVO != null) { @@ -279,16 +282,16 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu } } - private Date scheduleNextSnapshotJob(SnapshotScheduleVO snapshotSchedule) { + private Date scheduleNextSnapshotJob(final SnapshotScheduleVO snapshotSchedule) { if (snapshotSchedule == null) { return null; } - Long policyId = snapshotSchedule.getPolicyId(); + final Long policyId = snapshotSchedule.getPolicyId(); if (policyId.longValue() == Snapshot.MANUAL_POLICY_ID) { // Don't need to schedule the next job for this. return null; } - SnapshotPolicyVO snapshotPolicy = _snapshotPolicyDao.findById(policyId); + final SnapshotPolicyVO snapshotPolicy = _snapshotPolicyDao.findById(policyId); if (snapshotPolicy == null) { _snapshotScheduleDao.expunge(snapshotSchedule.getId()); } @@ -297,15 +300,15 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu @Override @DB - public Date scheduleNextSnapshotJob(SnapshotPolicyVO policy) { + public Date scheduleNextSnapshotJob(final SnapshotPolicyVO policy) { if (policy == null) { return null; } - long policyId = policy.getId(); + final long policyId = policy.getId(); if (policyId == Snapshot.MANUAL_POLICY_ID) { return null; } - Date nextSnapshotTimestamp = getNextScheduledTime(policyId, _currentTimestamp); + final Date nextSnapshotTimestamp = getNextScheduledTime(policyId, _currentTimestamp); SnapshotScheduleVO spstSchedVO = _snapshotScheduleDao.findOneByVolumePolicy(policy.getVolumeId(), policy.getId()); if (spstSchedVO == null) { spstSchedVO = new SnapshotScheduleVO(policy.getVolumeId(), policyId, nextSnapshotTimestamp); @@ -329,9 +332,9 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu @Override @DB - public boolean removeSchedule(Long volumeId, Long policyId) { + public boolean removeSchedule(final Long volumeId, final Long policyId) { // We can only remove schedules which are in the future. Not which are already executed in the past. - SnapshotScheduleVO schedule = _snapshotScheduleDao.getCurrentSchedule(volumeId, policyId, false); + final SnapshotScheduleVO schedule = _snapshotScheduleDao.getCurrentSchedule(volumeId, policyId, false); boolean success = true; if (schedule != null) { success = _snapshotScheduleDao.remove(schedule.getId()); @@ -343,18 +346,18 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu } @Override - public boolean configure(String name, Map params) throws ConfigurationException { + public boolean configure(final String name, final Map params) throws ConfigurationException { _snapshotPollInterval = NumbersUtil.parseInt(_configDao.getValue("snapshot.poll.interval"), 300); - boolean snapshotsRecurringTest = Boolean.parseBoolean(_configDao.getValue("snapshot.recurring.test")); + final boolean snapshotsRecurringTest = Boolean.parseBoolean(_configDao.getValue("snapshot.recurring.test")); if (snapshotsRecurringTest) { // look for some test values in the configuration table so that snapshots can be taken more frequently (QA test code) - int minutesPerHour = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.minutes.per.hour"), 60); - int hoursPerDay = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.hours.per.day"), 24); - int daysPerWeek = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.days.per.week"), 7); - int daysPerMonth = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.days.per.month"), 30); - int weeksPerMonth = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.weeks.per.month"), 4); - int monthsPerYear = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.months.per.year"), 12); + final int minutesPerHour = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.minutes.per.hour"), 60); + final int hoursPerDay = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.hours.per.day"), 24); + final int daysPerWeek = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.days.per.week"), 7); + final int daysPerMonth = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.days.per.month"), 30); + final int weeksPerMonth = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.weeks.per.month"), 4); + final int monthsPerYear = NumbersUtil.parseInt(_configDao.getValue("snapshot.test.months.per.year"), 12); _testTimerTask = new TestClock(this, minutesPerHour, hoursPerDay, daysPerWeek, daysPerMonth, weeksPerMonth, monthsPerYear); } @@ -369,8 +372,8 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu @DB public boolean start() { // reschedule all policies after management restart - List policyInstances = _snapshotPolicyDao.listAll(); - for (SnapshotPolicyVO policyInstance : policyInstances) { + final List policyInstances = _snapshotPolicyDao.listAll(); + for (final SnapshotPolicyVO policyInstance : policyInstances) { if (policyInstance.getId() != Snapshot.MANUAL_POLICY_ID) { scheduleNextSnapshotJob(policyInstance); } @@ -381,13 +384,13 @@ public class SnapshotSchedulerImpl extends ManagerBase implements SnapshotSchedu // Else it becomes too confusing. _testClockTimer.schedule(_testTimerTask, 100 * 1000L, 60 * 1000L); } else { - TimerTask timerTask = new ManagedContextTimerTask() { + final TimerTask timerTask = new ManagedContextTimerTask() { @Override protected void runInContext() { try { - Date currentTimestamp = new Date(); + final Date currentTimestamp = new Date(); poll(currentTimestamp); - } catch (Throwable t) { + } catch (final Throwable t) { s_logger.warn("Catch throwable in snapshot scheduler ", t); } } diff --git a/server/test/com/cloud/api/dispatch/CommandCreationWorkerTest.java b/server/test/com/cloud/api/dispatch/CommandCreationWorkerTest.java new file mode 100644 index 00000000000..34d64fc3c1b --- /dev/null +++ b/server/test/com/cloud/api/dispatch/CommandCreationWorkerTest.java @@ -0,0 +1,48 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import java.util.HashMap; +import java.util.Map; + +import org.junit.Test; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +import org.apache.cloudstack.api.BaseAsyncCreateCmd; + +import com.cloud.exception.ResourceAllocationException; + +public class CommandCreationWorkerTest { + + @Test + public void testHandle() throws ResourceAllocationException { + // Prepare + final BaseAsyncCreateCmd asyncCreateCmd = mock(BaseAsyncCreateCmd.class); + final Map params = new HashMap(); + + // Execute + final CommandCreationWorker creationWorker = new CommandCreationWorker(); + + creationWorker.handle(new DispatchTask(asyncCreateCmd, params)); + + // Assert + verify(asyncCreateCmd, times(1)).create(); + } +} diff --git a/server/test/com/cloud/api/dispatch/DispatchChainFactoryTest.java b/server/test/com/cloud/api/dispatch/DispatchChainFactoryTest.java new file mode 100644 index 00000000000..f54caae5141 --- /dev/null +++ b/server/test/com/cloud/api/dispatch/DispatchChainFactoryTest.java @@ -0,0 +1,55 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import org.junit.Test; +import static org.junit.Assert.assertEquals; + +public class DispatchChainFactoryTest { + + protected static final String STANDARD_CHAIN_ERROR = "Expecting worker of class %s at index %s of StandardChain"; + protected static final String ASYNC_CHAIN_ERROR = "Expecting worker of class %s at index %s of StandardChain"; + + @Test + public void testAllChainCreation() { + // Prepare + final DispatchChainFactory dispatchChainFactory = new DispatchChainFactory(); + dispatchChainFactory.paramGenericValidationWorker = new ParamGenericValidationWorker(); + dispatchChainFactory.specificCmdValidationWorker = new SpecificCmdValidationWorker(); + dispatchChainFactory.paramProcessWorker = new ParamProcessWorker(); + dispatchChainFactory.commandCreationWorker = new CommandCreationWorker(); + dispatchChainFactory.paramUnpackWorker = new ParamUnpackWorker(); + + final Class[] standardClasses = {ParamUnpackWorker.class, ParamProcessWorker.class, + ParamGenericValidationWorker.class, SpecificCmdValidationWorker.class}; + final Class[] asyncClasses = {ParamUnpackWorker.class, ParamProcessWorker.class, + ParamGenericValidationWorker.class, SpecificCmdValidationWorker.class, CommandCreationWorker.class}; + + // Execute + dispatchChainFactory.setup(); + final DispatchChain standardChain = dispatchChainFactory.getStandardDispatchChain(); + final DispatchChain asyncChain = dispatchChainFactory.getAsyncCreationDispatchChain(); + for (int i = 0; i < standardClasses.length; i++) { + assertEquals(String.format(STANDARD_CHAIN_ERROR, standardClasses[i], i), + standardClasses[i], standardChain.workers.get(i).getClass()); + } + for (int i = 0; i < asyncClasses.length; i++) { + assertEquals(String.format(ASYNC_CHAIN_ERROR, asyncClasses[i], i), + asyncClasses[i], asyncChain.workers.get(i).getClass()); + } + } +} diff --git a/server/test/com/cloud/api/dispatch/ParamGenericValidationWorkerTest.java b/server/test/com/cloud/api/dispatch/ParamGenericValidationWorkerTest.java new file mode 100644 index 00000000000..867625da2d8 --- /dev/null +++ b/server/test/com/cloud/api/dispatch/ParamGenericValidationWorkerTest.java @@ -0,0 +1,173 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import java.util.HashMap; +import java.util.Map; + +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.apache.cloudstack.acl.RoleType; +import org.apache.cloudstack.api.APICommand; +import org.apache.cloudstack.api.ApiConstants; +import org.apache.cloudstack.api.BaseCmd; +import org.apache.cloudstack.api.BaseResponse; +import org.apache.cloudstack.api.Parameter; +import org.apache.cloudstack.api.ServerApiException; + +import com.cloud.exception.ConcurrentOperationException; +import com.cloud.exception.InsufficientCapacityException; +import com.cloud.exception.NetworkRuleConflictException; +import com.cloud.exception.ResourceAllocationException; +import com.cloud.exception.ResourceUnavailableException; +import com.cloud.user.Account; + +import org.apache.log4j.Logger; + +public class ParamGenericValidationWorkerTest { + + protected static final String FAKE_CMD_NAME = "fakecmdname"; + + protected static final String FAKE_CMD_ROLE_NAME = "fakecmdrolename"; + + protected String loggerOutput; + + protected void driveTest(final BaseCmd cmd, final Map params) { + final ParamGenericValidationWorker genValidationWorker = new ParamGenericValidationWorker(); + + // We create a mock logger to verify the result + ParamGenericValidationWorker.s_logger = new Logger(""){ + @Override + public void warn(final Object msg){ + loggerOutput = msg.toString(); + } + }; + + // Execute + genValidationWorker.handle(new DispatchTask(cmd, params)); + } + + @Test + public void testHandle() throws ResourceAllocationException { + // Prepare + final BaseCmd cmd = new FakeCmd(); + final Map params = new HashMap(); + params.put(ApiConstants.COMMAND, ""); + params.put("addedParam", ""); + + // Execute + driveTest(cmd, params); + + // Assert + assertEquals("There should be no errors since there are no unknown parameters for this command class", null, loggerOutput); + } + + @Test + public void testHandleWithUnknownParams() throws ResourceAllocationException { + // Prepare + final String unknownParamKey = "unknownParam"; + final BaseCmd cmd = new FakeCmd(); + final Map params = new HashMap(); + params.put(ApiConstants.COMMAND, ""); + params.put("addedParam", ""); + params.put(unknownParamKey, ""); + + // Execute + driveTest(cmd, params); + + // Assert + assertTrue("There should be error msg, since there is one unknown parameter", loggerOutput.contains(unknownParamKey)); + assertTrue("There should be error msg containing the correct command name", loggerOutput.contains(FAKE_CMD_NAME)); + } + + @Test + public void testHandleWithoutAuthorization() throws ResourceAllocationException { + final short type = Account.ACCOUNT_TYPE_NORMAL; + driveAuthTest(type); + + // Assert + assertTrue("There should be error msg, since there is one unauthorized parameter", loggerOutput.contains("paramWithRole")); + assertTrue("There should be error msg containing the correct command name", loggerOutput.contains(FAKE_CMD_ROLE_NAME)); + } + + @Test + public void testHandleWithAuthorization() throws ResourceAllocationException { + final short type = Account.ACCOUNT_TYPE_ADMIN; + driveAuthTest(type); + + // Assert + assertEquals("There should be no errors since parameters have authorization", null, loggerOutput); + } + + protected void driveAuthTest(final short type) { + // Prepare + final BaseCmd cmd = new FakeCmdWithRoleAdmin(); + final Account account = mock(Account.class); + ((FakeCmdWithRoleAdmin)cmd).account = account; + when(account.getType()).thenReturn(type); + final Map params = new HashMap(); + params.put(ApiConstants.COMMAND, ""); + params.put("addedParam", ""); + params.put("paramWithRole", ""); + + // Execute + driveTest(cmd, params); + } +} + + +@APICommand(name=ParamGenericValidationWorkerTest.FAKE_CMD_NAME, responseObject=BaseResponse.class) +class FakeCmd extends BaseCmd { + + @Parameter(name = "addedParam") + private String addedParam; + + public Account account; + + @Override + protected Account getCurrentContextAccount() { + return account; + } + + // + // Dummy methods for mere correct compilation + // + @Override + public void execute() throws ResourceUnavailableException, InsufficientCapacityException, ServerApiException, ConcurrentOperationException, ResourceAllocationException, + NetworkRuleConflictException { + } + @Override + public String getCommandName() { + return null; + } + @Override + public long getEntityOwnerId() { + return 0; + } +} + +@APICommand(name=ParamGenericValidationWorkerTest.FAKE_CMD_ROLE_NAME, responseObject=BaseResponse.class) +class FakeCmdWithRoleAdmin extends FakeCmd { + + @Parameter(name = "paramWithRole", authorized = {RoleType.Admin}) + private String paramWithRole; +} diff --git a/server/test/com/cloud/api/ApiDispatcherTest.java b/server/test/com/cloud/api/dispatch/ParamProcessWorkerTest.java similarity index 86% rename from server/test/com/cloud/api/ApiDispatcherTest.java rename to server/test/com/cloud/api/dispatch/ParamProcessWorkerTest.java index 7314a57b468..12051a6f743 100644 --- a/server/test/com/cloud/api/ApiDispatcherTest.java +++ b/server/test/com/cloud/api/dispatch/ParamProcessWorkerTest.java @@ -16,7 +16,7 @@ * specific language governing permissions and limitations * under the License. */ -package com.cloud.api; +package com.cloud.api.dispatch; import java.util.HashMap; @@ -44,10 +44,12 @@ import com.cloud.user.AccountManager; import com.cloud.user.User; @RunWith(MockitoJUnitRunner.class) -public class ApiDispatcherTest { +public class ParamProcessWorkerTest { @Mock - AccountManager accountManager; + protected AccountManager accountManager; + + protected ParamProcessWorker paramProcessWorker; public static class TestCmd extends BaseCmd { @@ -81,8 +83,8 @@ public class ApiDispatcherTest { @Before public void setup() { CallContext.register(Mockito.mock(User.class), Mockito.mock(Account.class)); - new ApiDispatcher().init(); - ApiDispatcher.getInstance()._accountMgr = accountManager; + paramProcessWorker = new ParamProcessWorker(); + paramProcessWorker._accountMgr = accountManager; } @After @@ -92,13 +94,12 @@ public class ApiDispatcherTest { @Test public void processParameters() { - HashMap params = new HashMap(); + final HashMap params = new HashMap(); params.put("strparam1", "foo"); params.put("intparam1", "100"); params.put("boolparam1", "true"); - TestCmd cmd = new TestCmd(); - //how lucky that field is not protected, this test would be impossible - ApiDispatcher.processParameters(cmd, params); + final TestCmd cmd = new TestCmd(); + paramProcessWorker.processParameters(cmd, params); Assert.assertEquals("foo", cmd.strparam1); Assert.assertEquals(100, cmd.intparam1); } diff --git a/server/test/com/cloud/api/dispatch/SpecificCmdValidationWorkerTest.java b/server/test/com/cloud/api/dispatch/SpecificCmdValidationWorkerTest.java new file mode 100644 index 00000000000..4ae720060f0 --- /dev/null +++ b/server/test/com/cloud/api/dispatch/SpecificCmdValidationWorkerTest.java @@ -0,0 +1,48 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you 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.cloud.api.dispatch; + +import java.util.HashMap; +import java.util.Map; + +import org.junit.Test; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; + +import org.apache.cloudstack.api.BaseCmd; + +import com.cloud.exception.ResourceAllocationException; + +public class SpecificCmdValidationWorkerTest { + + @Test + public void testHandle() throws ResourceAllocationException { + // Prepare + final BaseCmd cmd = mock(BaseCmd.class); + final Map params = new HashMap(); + + // Execute + final SpecificCmdValidationWorker worker = new SpecificCmdValidationWorker(); + + worker.handle(new DispatchTask(cmd, params)); + + // Assert + verify(cmd, times(1)).validateSpecificParameters(params); + } +}