// 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;

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;

import com.cloud.domain.DomainVO;

import com.cloud.domain.dao.DomainDao;

import com.cloud.event.ActionEventUtils;

import com.cloud.event.EventCategory;

import com.cloud.event.EventTypes;

import com.cloud.exception.AccountLimitException;

import com.cloud.exception.CloudAuthenticationException;

import com.cloud.exception.InsufficientCapacityException;

import com.cloud.exception.InvalidParameterValueException;

import com.cloud.exception.PermissionDeniedException;

import com.cloud.exception.RequestLimitException;

import com.cloud.exception.ResourceAllocationException;

import com.cloud.exception.ResourceUnavailableException;

import com.cloud.user.Account;

import com.cloud.user.AccountManager;

import com.cloud.user.DomainManager;

import com.cloud.user.User;

import com.cloud.user.UserAccount;

import com.cloud.user.UserVO;

import com.cloud.utils.ConstantTimeComparator;

import com.cloud.utils.HttpUtils;

import com.cloud.utils.NumbersUtil;

import com.cloud.utils.Pair;

import com.cloud.utils.ReflectUtil;

import com.cloud.utils.StringUtils;

import com.cloud.utils.component.ComponentContext;

import com.cloud.utils.component.ManagerBase;

import com.cloud.utils.component.PluggableService;

import com.cloud.utils.concurrency.NamedThreadFactory;

import com.cloud.utils.db.EntityManager;

import com.cloud.utils.db.SearchCriteria;

import com.cloud.utils.db.TransactionLegacy;

import com.cloud.utils.db.UUIDManager;

import com.cloud.utils.exception.CloudRuntimeException;

import com.cloud.utils.exception.ExceptionProxyObject;

import com.google.gson.reflect.TypeToken;

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.ApiServerService;

import org.apache.cloudstack.api.BaseAsyncCmd;

import org.apache.cloudstack.api.BaseAsyncCreateCmd;

import org.apache.cloudstack.api.BaseCmd;

import org.apache.cloudstack.api.BaseListCmd;

import org.apache.cloudstack.api.Parameter;

import org.apache.cloudstack.api.ResponseObject;

import org.apache.cloudstack.api.ResponseObject.ResponseView;

import org.apache.cloudstack.api.ServerApiException;

import org.apache.cloudstack.api.auth.APIAuthenticationManager;

import org.apache.cloudstack.api.command.admin.account.ListAccountsCmdByAdmin;

import org.apache.cloudstack.api.command.admin.host.ListHostsCmd;

import org.apache.cloudstack.api.command.admin.router.ListRoutersCmd;

import org.apache.cloudstack.api.command.admin.storage.ListStoragePoolsCmd;

import org.apache.cloudstack.api.command.admin.user.ListUsersCmd;

import org.apache.cloudstack.api.command.admin.vm.ListVMsCmdByAdmin;

import org.apache.cloudstack.api.command.admin.volume.ListVolumesCmdByAdmin;

import org.apache.cloudstack.api.command.admin.zone.ListZonesCmdByAdmin;

import org.apache.cloudstack.api.command.user.account.ListAccountsCmd;

import org.apache.cloudstack.api.command.user.account.ListProjectAccountsCmd;

import org.apache.cloudstack.api.command.user.event.ListEventsCmd;

import org.apache.cloudstack.api.command.user.offering.ListDiskOfferingsCmd;

import org.apache.cloudstack.api.command.user.offering.ListServiceOfferingsCmd;

import org.apache.cloudstack.api.command.user.project.ListProjectInvitationsCmd;

import org.apache.cloudstack.api.command.user.project.ListProjectsCmd;

import org.apache.cloudstack.api.command.user.securitygroup.ListSecurityGroupsCmd;

import org.apache.cloudstack.api.command.user.tag.ListTagsCmd;

import org.apache.cloudstack.api.command.user.vm.ListVMsCmd;

import org.apache.cloudstack.api.command.user.vmgroup.ListVMGroupsCmd;

import org.apache.cloudstack.api.command.user.volume.ListVolumesCmd;

import org.apache.cloudstack.api.command.user.zone.ListZonesCmd;

import org.apache.cloudstack.api.response.AsyncJobResponse;

import org.apache.cloudstack.api.response.CreateCmdResponse;

import org.apache.cloudstack.api.response.ExceptionResponse;

import org.apache.cloudstack.api.response.ListResponse;

import org.apache.cloudstack.api.response.LoginCmdResponse;

import org.apache.cloudstack.context.CallContext;

import org.apache.cloudstack.framework.config.ConfigKey;

import org.apache.cloudstack.framework.config.Configurable;

import org.apache.cloudstack.framework.config.dao.ConfigurationDao;

import org.apache.cloudstack.framework.config.impl.ConfigurationVO;

import org.apache.cloudstack.framework.events.EventBus;

import org.apache.cloudstack.framework.events.EventBusException;

import org.apache.cloudstack.framework.jobs.AsyncJob;

import org.apache.cloudstack.framework.jobs.AsyncJobManager;

import org.apache.cloudstack.framework.jobs.impl.AsyncJobVO;

import org.apache.cloudstack.framework.messagebus.MessageBus;

import org.apache.cloudstack.framework.messagebus.MessageDispatcher;

import org.apache.cloudstack.framework.messagebus.MessageHandler;

import org.apache.cloudstack.managed.context.ManagedContextRunnable;

import org.apache.commons.codec.binary.Base64;

import org.apache.http.ConnectionClosedException;

import org.apache.http.HttpException;

import org.apache.http.HttpRequest;

import org.apache.http.HttpResponse;

import org.apache.http.HttpServerConnection;

import org.apache.http.HttpStatus;

import org.apache.http.NameValuePair;

import org.apache.http.client.utils.URLEncodedUtils;

import org.apache.http.entity.BasicHttpEntity;

import org.apache.http.impl.DefaultHttpResponseFactory;

import org.apache.http.impl.DefaultHttpServerConnection;

import org.apache.http.impl.NoConnectionReuseStrategy;

import org.apache.http.impl.SocketHttpServerConnection;

import org.apache.http.params.BasicHttpParams;

import org.apache.http.params.CoreConnectionPNames;

import org.apache.http.params.CoreProtocolPNames;

import org.apache.http.params.HttpParams;

import org.apache.http.protocol.BasicHttpContext;

import org.apache.http.protocol.BasicHttpProcessor;

import org.apache.http.protocol.HttpContext;

import org.apache.http.protocol.HttpRequestHandler;

import org.apache.http.protocol.HttpRequestHandlerRegistry;

import org.apache.http.protocol.HttpService;

import org.apache.http.protocol.ResponseConnControl;

import org.apache.http.protocol.ResponseContent;

import org.apache.http.protocol.ResponseDate;

import org.apache.http.protocol.ResponseServer;

import org.apache.log4j.Logger;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import org.springframework.beans.factory.NoSuchBeanDefinitionException;

import org.springframework.stereotype.Component;

import javax.crypto.Mac;

import javax.crypto.spec.SecretKeySpec;

import javax.inject.Inject;

import javax.naming.ConfigurationException;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import java.io.ByteArrayInputStream;

import java.io.IOException;

import java.io.InterruptedIOException;

import java.lang.reflect.Type;

import java.lang.reflect.Field;

import java.net.InetAddress;

import java.net.ServerSocket;

import java.net.Socket;

import java.net.URI;

import java.net.URISyntaxException;

import java.net.URLEncoder;

import java.security.SecureRandom;

import java.security.Security;

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Date;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.TimeZone;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.LinkedBlockingQueue;

import java.util.concurrent.ThreadPoolExecutor;

import java.util.concurrent.TimeUnit;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

@Component

public class ApiServer extends ManagerBase implements HttpRequestHandler, ApiServerService, Configurable {

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;

/**

* Non-printable ASCII characters - numbers 0 to 31 and 127 decimal

*/

private static final String CONTROL_CHARACTERS = "[\000-\011\013-\014\016-\037\177]";

@Inject

private ApiDispatcher dispatcher;

@Inject

private DispatchChainFactory dispatchChainFactory;

@Inject

private AccountManager accountMgr;

@Inject

private DomainManager domainMgr;

@Inject

private DomainDao domainDao;

@Inject

private UUIDManager uuidMgr;

@Inject

private AsyncJobManager asyncMgr;

@Inject

private ConfigurationDao configDao;

@Inject

private EntityManager entityMgr;

@Inject

private APIAuthenticationManager authManager;

private List<PluggableService> pluggableServices;

private List<APIChecker> apiAccessCheckers;

@Inject

private ApiAsyncJobDispatcher asyncDispatcher;

private static int s_workerCount = 0;

private static final DateFormat DateFormatToUse = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZ");

private static Map<String, List<Class<?>>> s_apiNameCmdClassMap = new HashMap<String, List<Class<?>>>();

private static ExecutorService s_executor = new ThreadPoolExecutor(10, 150, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), new NamedThreadFactory(

"ApiServer"));

static final ConfigKey<Boolean> EnableSecureSessionCookie = new ConfigKey<Boolean>("Advanced", Boolean.class, "enable.secure.session.cookie", "false",

"Session cookie is marked as secure if this is enabled. Secure cookies only work when HTTPS is used.", false);

static final ConfigKey<String> JSONcontentType = new ConfigKey<String>(String.class, "json.content.type", "Advanced", "application/json; charset=UTF-8",

"Http response content type for .js files (default is text/javascript)", false, ConfigKey.Scope.Global, null);

@Inject

private MessageBus messageBus;

@Override

public boolean configure(final String name, final Map<String, Object> params) throws ConfigurationException {

messageBus.subscribe(AsyncJob.Topics.JOB_EVENT_PUBLISH, MessageDispatcher.getDispatcher(this));

return true;

}

@MessageHandler(topic = AsyncJob.Topics.JOB_EVENT_PUBLISH)

public void handleAsyncJobPublishEvent(String subject, String senderAddress, Object args) {

assert (args != null);

@SuppressWarnings("unchecked")

Pair<AsyncJob, String> eventInfo = (Pair<AsyncJob, String>)args;

AsyncJob job = eventInfo.first();

String jobEvent = eventInfo.second();

if (s_logger.isTraceEnabled())

s_logger.trace("Handle asyjob publish event " + jobEvent);

EventBus eventBus = null;

try {

eventBus = ComponentContext.getComponent(EventBus.class);

} catch (NoSuchBeanDefinitionException nbe) {

return; // no provider is configured to provide events bus, so just return

}

if (!job.getDispatcher().equalsIgnoreCase("ApiAsyncJobDispatcher")) {

return;

}

User userJobOwner = accountMgr.getUserIncludingRemoved(job.getUserId());

Account jobOwner = accountMgr.getAccount(userJobOwner.getAccountId());

// Get the event type from the cmdInfo json string

String info = job.getCmdInfo();

String cmdEventType = "unknown";

if (info != null) {

Type type = new TypeToken<Map<String, String>>(){}.getType();

Map<String, String> cmdInfo = ApiGsonHelper.getBuilder().create().fromJson(info, type);

String eventTypeObj = cmdInfo.get("cmdEventType");

if (eventTypeObj != null) {

cmdEventType = eventTypeObj;

if (s_logger.isDebugEnabled())

s_logger.debug("Retrieved cmdEventType from job info: " + cmdEventType);

} else {

if (s_logger.isDebugEnabled())

s_logger.debug("Unable to locate cmdEventType marker in job info. publish as unknown event");

}

}

// For some reason, the instanceType / instanceId are not abstract, which means we may get null values.

String instanceType = job.getInstanceType() != null ? job.getInstanceType() : "unknown";

String instanceUuid = job.getInstanceId() != null ? ApiDBUtils.findJobInstanceUuid(job) : "";

org.apache.cloudstack.framework.events.Event event = new org.apache.cloudstack.framework.events.Event("management-server", EventCategory.ASYNC_JOB_CHANGE_EVENT.getName(),

jobEvent, instanceType, instanceUuid);

Map<String, String> eventDescription = new HashMap<String, String>();

eventDescription.put("command", job.getCmd());

eventDescription.put("user", userJobOwner.getUuid());

eventDescription.put("account", jobOwner.getUuid());

eventDescription.put("processStatus", "" + job.getProcessStatus());

eventDescription.put("resultCode", "" + job.getResultCode());

eventDescription.put("instanceUuid", instanceUuid);

eventDescription.put("instanceType", instanceType);

eventDescription.put("commandEventType", cmdEventType);

eventDescription.put("jobId", job.getUuid());

eventDescription.put("jobResult", job.getResult());

eventDescription.put("cmdInfo", job.getCmdInfo());

eventDescription.put("status", "" + job.getStatus() );

// If the event.accountinfo boolean value is set, get the human readable value for the username / domainname

Map<String, String> configs = configDao.getConfiguration("management-server", new HashMap<String, String>());

if (Boolean.valueOf(configs.get("event.accountinfo"))) {

DomainVO domain = domainDao.findById(jobOwner.getDomainId());

eventDescription.put("username", userJobOwner.getUsername());

eventDescription.put("accountname", jobOwner.getAccountName());

eventDescription.put("domainname", domain.getName());

}

event.setDescription(eventDescription);

try {

eventBus.publish(event);

} catch (EventBusException evx) {

String errMsg = "Failed to publish async job event on the the event bus.";

s_logger.warn(errMsg, evx);

}

}

@Override

public boolean start() {

Security.addProvider(new BouncyCastleProvider());

Integer apiPort = null; // api port, null by default

final SearchCriteria<ConfigurationVO> sc = configDao.createSearchCriteria();

sc.addAnd("name", SearchCriteria.Op.EQ, Config.IntegrationAPIPort.key());

final List<ConfigurationVO> values = configDao.search(sc, null);

if ((values != null) && (values.size() > 0)) {

final ConfigurationVO apiPortConfig = values.get(0);

if (apiPortConfig.getValue() != null) {

apiPort = Integer.parseInt(apiPortConfig.getValue());

}

}

final Map<String, String> configs = configDao.getConfiguration();

final String strSnapshotLimit = configs.get(Config.ConcurrentSnapshotsThresholdPerHost.key());

if (strSnapshotLimit != null) {

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 {

dispatcher.setCreateSnapshotQueueSizeLimit(snapshotLimit);

}

}

final Set<Class<?>> cmdClasses = new HashSet<Class<?>>();

for (final PluggableService pluggableService : pluggableServices) {

cmdClasses.addAll(pluggableService.getCommands());

if (s_logger.isDebugEnabled()) {

s_logger.debug("Discovered plugin " + pluggableService.getClass().getSimpleName());

}

}

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();

List<Class<?>> apiCmdList = s_apiNameCmdClassMap.get(apiName);

if (apiCmdList == null) {

apiCmdList = new ArrayList<Class<?>>();

s_apiNameCmdClassMap.put(apiName, apiCmdList);

}

apiCmdList.add(cmdClass);

}

setEncodeApiResponse(Boolean.valueOf(configDao.getValue(Config.EncodeApiResponse.key())));

if (apiPort != null) {

final ListenerThread listenerThread = new ListenerThread(this, apiPort);

listenerThread.start();

}

return true;

}

// NOTE: handle() only handles over the wire (OTW) requests from integration.api.port 8096

// If integration api port is not configured, actual OTW requests will be received by ApiServlet

@SuppressWarnings({"unchecked", "rawtypes"})

@Override

public void handle(final HttpRequest request, final HttpResponse response, final HttpContext context) throws HttpException, IOException {

// Create StringBuffer to log information in access log

final StringBuilder sb = new StringBuilder();

final HttpServerConnection connObj = (HttpServerConnection)context.getAttribute("http.connection");

if (connObj instanceof SocketHttpServerConnection) {

final InetAddress remoteAddr = ((SocketHttpServerConnection)connObj).getRemoteAddress();

sb.append(remoteAddr.toString() + " -- ");

}

sb.append(StringUtils.cleanString(request.getRequestLine().toString()));

try {

List<NameValuePair> paramList = null;

try {

paramList = URLEncodedUtils.parse(new URI(request.getRequestLine().getUri()), HttpUtils.UTF_8);

} catch (final URISyntaxException e) {

s_logger.error("Error parsing url request", e);

}

// Use Multimap as the parameter map should be in the form (name=String, value=String[])

// So parameter values are stored in a list for the same name key

// APITODO: Use Guava's (import com.google.common.collect.Multimap;)

// (Immutable)Multimap<String, String> paramMultiMap = HashMultimap.create();

// Map<String, Collection<String>> parameterMap = paramMultiMap.asMap();

final Map parameterMap = new HashMap<String, String[]>();

String responseType = HttpUtils.RESPONSE_TYPE_XML;

if(paramList != null) {

for (final NameValuePair param : paramList) {

if (param.getName().equalsIgnoreCase("response")) {

responseType = param.getValue();

continue;

}

parameterMap.put(param.getName(), new String[]{param.getValue()});

}

}

// Get the type of http method being used.

parameterMap.put("httpmethod", new String[] {request.getRequestLine().getMethod()});

// Check responseType, if not among valid types, fallback to JSON

if (!(responseType.equals(HttpUtils.RESPONSE_TYPE_JSON) || responseType.equals(HttpUtils.RESPONSE_TYPE_XML))) {

responseType = HttpUtils.RESPONSE_TYPE_XML;

}

try {

//verify that parameter is legit for passing via admin port

String[] command = (String[]) parameterMap.get("command");

if (command != null) {

Class<?> cmdClass = getCmdClass(command[0]);

if (cmdClass != null) {

List<Field> fields = ReflectUtil.getAllFieldsForClass(cmdClass, BaseCmd.class);

for (Field field : fields) {

Parameter parameterAnnotation = field.getAnnotation(Parameter.class);

if ((parameterAnnotation == null) || !parameterAnnotation.expose()) {

continue;

}

Object paramObj = parameterMap.get(parameterAnnotation.name());

if (paramObj != null) {

if (!parameterAnnotation.acceptedOnAdminPort()) {

throw new ServerApiException(ApiErrorCode.ACCOUNT_ERROR, "Parameter " + parameterAnnotation.name() + " can't be passed through the API integration port");

}

}

}

}

}

// 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 + ") ");

final String responseText = handleRequest(parameterMap, responseType, sb);

sb.append(" 200 " + ((responseText == null) ? 0 : responseText.length()));

writeResponse(response, responseText, HttpStatus.SC_OK, responseType, null);

} 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 (final RuntimeException e) {

// log runtime exception like NullPointerException to help identify the source easier

s_logger.error("Unhandled exception, ", e);

throw e;

}

} finally {

s_accessLogger.info(sb.toString());

CallContext.unregister();

}

}

@SuppressWarnings({"unchecked", "rawtypes"})

public void checkCharacterInkParams(final Map params) {

final Map<String, String> stringMap = new HashMap<String, String>();

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 containing illegal ASCII non-printable characters for parameter " + key);

}

}

stringMap.put(key, value[0]);

}

}

@Override

@SuppressWarnings("rawtypes")

public String handleRequest(final Map params, final String responseType, final StringBuilder auditTrailSb) throws ServerApiException {

checkCharacterInkParams(params);

String response = null;

String[] command = null;

try {

command = (String[])params.get("command");

if (command == null) {

s_logger.error("invalid request, no command sent");

if (s_logger.isTraceEnabled()) {

s_logger.trace("dumping request parameters");

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 {

// Don't allow Login/Logout APIs to go past this point

if (authManager.getAPIAuthenticator(command[0]) != null) {

return null;

}

final Map<String, String> paramMap = new HashMap<String, String>();

final Set keys = params.keySet();

final Iterator keysIter = keys.iterator();

while (keysIter.hasNext()) {

final String key = (String)keysIter.next();

if ("command".equalsIgnoreCase(key)) {

continue;

}

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) {

s_logger.error("No APICommand annotation found for class " + cmdClass.getCanonicalName());

throw new CloudRuntimeException("No APICommand annotation found for class " + cmdClass.getCanonicalName());

}

BaseCmd cmdObj = (BaseCmd)cmdClass.newInstance();

cmdObj = ComponentContext.inject(cmdObj);

cmdObj.configure();

cmdObj.setFullUrlParams(paramMap);

cmdObj.setResponseType(responseType);

cmdObj.setHttpMethod(paramMap.get(ApiConstants.HTTPMETHOD).toString());

// This is where the command is either serialized, or directly dispatched

StringBuilder log = new StringBuilder();

response = queueCommand(cmdObj, paramMap, log);

buildAuditTrail(auditTrailSb, command[0], log.toString());

} else {

final String errorString = "Unknown API command: " + command[0];

s_logger.warn(errorString);

auditTrailSb.append(" " + errorString);

throw new ServerApiException(ApiErrorCode.UNSUPPORTED_ACTION_ERROR, errorString);

}

}

} catch (final InvalidParameterValueException ex) {

s_logger.info(ex.getMessage());

throw new ServerApiException(ApiErrorCode.PARAM_ERROR, ex.getMessage(), ex);

} catch (final IllegalArgumentException ex) {

s_logger.info(ex.getMessage());

throw new ServerApiException(ApiErrorCode.PARAM_ERROR, ex.getMessage(), ex);

} catch (final PermissionDeniedException ex) {

final ArrayList<ExceptionProxyObject> idList = ex.getIdProxyList();

if (idList != null) {

final StringBuffer buf = new StringBuffer();

for (final ExceptionProxyObject obj : idList) {

buf.append(obj.getDescription());

buf.append(":");

buf.append(obj.getUuid());

buf.append(" ");

}

s_logger.info("PermissionDenied: " + ex.getMessage() + " on objs: [" + buf.toString() + "]");

} else {

s_logger.info("PermissionDenied: " + ex.getMessage());

}

throw new ServerApiException(ApiErrorCode.ACCOUNT_ERROR, ex.getMessage(), ex);

} catch (final AccountLimitException ex) {

s_logger.info(ex.getMessage());

throw new ServerApiException(ApiErrorCode.ACCOUNT_RESOURCE_LIMIT_ERROR, ex.getMessage(), ex);

} catch (final InsufficientCapacityException ex) {

s_logger.info(ex.getMessage());

String errorMsg = ex.getMessage();

if (!accountMgr.isRootAdmin(CallContext.current().getCallingAccount().getId())) {

// hide internal details to non-admin user for security reason

errorMsg = BaseCmd.USER_ERROR_MESSAGE;

}

throw new ServerApiException(ApiErrorCode.INSUFFICIENT_CAPACITY_ERROR, errorMsg, ex);

} catch (final ResourceAllocationException ex) {

s_logger.info(ex.getMessage());

throw new ServerApiException(ApiErrorCode.RESOURCE_ALLOCATION_ERROR, ex.getMessage(), ex);

} catch (final ResourceUnavailableException ex) {

s_logger.info(ex.getMessage());

String errorMsg = ex.getMessage();

if (!accountMgr.isRootAdmin(CallContext.current().getCallingAccount().getId())) {

// hide internal details to non-admin user for security reason

errorMsg = BaseCmd.USER_ERROR_MESSAGE;

}

throw new ServerApiException(ApiErrorCode.RESOURCE_UNAVAILABLE_ERROR, errorMsg, ex);

} catch (final ServerApiException ex) {

s_logger.info(ex.getDescription());

throw ex;

} catch (final Exception ex) {

s_logger.error("unhandled exception executing api command: " + ((command == null) ? "null" : command), ex);

String errorMsg = ex.getMessage();

if (!accountMgr.isRootAdmin(CallContext.current().getCallingAccount().getId())) {

// hide internal details to non-admin user for security reason

errorMsg = BaseCmd.USER_ERROR_MESSAGE;

}

throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, errorMsg, ex);

}

return response;

}

private String getBaseAsyncResponse(final long jobId, final BaseAsyncCmd cmd) {

final AsyncJobResponse response = new AsyncJobResponse();

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(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(final BaseCmd cmdObj, final Map<String, String> params, StringBuilder log) 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.

// BaseAsyncCreateCmd: cmd params are processed and create() is called, then same workflow as BaseAsyncCmd.

// BaseAsyncCmd: cmd is processed and submitted as an AsyncJob, job related info is serialized and returned.

if (cmdObj instanceof BaseAsyncCmd) {

Long objectId = null;

String objectUuid = null;

if (cmdObj instanceof BaseAsyncCreateCmd) {

final BaseAsyncCreateCmd createCmd = (BaseAsyncCreateCmd)cmdObj;

dispatcher.dispatchCreateCmd(createCmd, params);

objectId = createCmd.getEntityId();

objectUuid = createCmd.getEntityUuid();

params.put("id", objectId.toString());

Class entityClass = EventTypes.getEntityClassForEvent(createCmd.getEventType());

if (entityClass != null)

ctx.putContextParameter(entityClass, objectUuid);

} else {

// Extract the uuid before params are processed and id reflects internal db id

objectUuid = params.get(ApiConstants.ID);

dispatchChainFactory.getStandardDispatchChain().dispatch(new DispatchTask(cmdObj, params));

}

final BaseAsyncCmd asyncCmd = (BaseAsyncCmd)cmdObj;

if (callerUserId != null) {

params.put("ctxUserId", callerUserId.toString());

}

if (caller != null) {

params.put("ctxAccountId", String.valueOf(caller.getId()));

}

if (objectUuid != null) {

params.put("uuid", objectUuid);

}

long startEventId = ctx.getStartEventId();

asyncCmd.setStartEventId(startEventId);

// save the scheduled event

final Long eventId =

ActionEventUtils.onScheduledActionEvent((callerUserId == null) ? (Long)User.UID_SYSTEM : callerUserId, asyncCmd.getEntityOwnerId(), asyncCmd.getEventType(),

asyncCmd.getEventDescription(), asyncCmd.isDisplay(), startEventId);

if (startEventId == 0) {

// There was no create event before, set current event id as start eventId

startEventId = eventId;

}

params.put("ctxStartEventId", String.valueOf(startEventId));

params.put("cmdEventType", asyncCmd.getEventType().toString());

params.put("ctxDetails", ApiGsonHelper.getBuilder().create().toJson(ctx.getContextParameters()));

Long instanceId = (objectId == null) ? asyncCmd.getInstanceId() : objectId;

// users can provide the job id they want to use, so log as it is a uuid and is unique

String injectedJobId = asyncCmd.getInjectedJobId();

uuidMgr.checkUuidSimple(injectedJobId, AsyncJob.class);

AsyncJobVO job = new AsyncJobVO("", callerUserId, caller.getId(), cmdObj.getClass().getName(),

ApiGsonHelper.getBuilder().create().toJson(params), instanceId,

asyncCmd.getInstanceType() != null ? asyncCmd.getInstanceType().toString() : null,

injectedJobId);

job.setDispatcher(asyncDispatcher.getName());

final long jobId = asyncMgr.submitAsyncJob(job);

if (jobId == 0L) {

final String errorMsg = "Unable to schedule async job for command " + job.getCmd();

s_logger.warn(errorMsg);

throw new ServerApiException(ApiErrorCode.INTERNAL_ERROR, errorMsg);

}

final String response;

if (objectId != null) {

final String objUuid = (objectUuid == null) ? objectId.toString() : objectUuid;

response = getBaseAsyncCreateResponse(jobId, (BaseAsyncCreateCmd)asyncCmd, objUuid);

} else {

SerializationContext.current().setUuidTranslation(true);

response = getBaseAsyncResponse(jobId, asyncCmd);

}

// Always log response for async for now, I don't think any sensitive data will be in here.

// It might be nice to send this through scrubbing similar to how

// ApiResponseSerializer.toSerializedStringWithSecureLogs works. For now, this gets jobid's

// in the api logs.

log.append(response);

return response;

} else {

dispatcher.dispatch(cmdObj, params, false);

// if the command is of the listXXXCommand, we will need to also return the

// the job id and status if possible

// For those listXXXCommand which we have already created DB views, this step is not needed since async job is joined in their db views.

if (cmdObj instanceof BaseListCmd && !(cmdObj instanceof ListVMsCmd) && !(cmdObj instanceof ListVMsCmdByAdmin) && !(cmdObj instanceof ListRoutersCmd)

&& !(cmdObj instanceof ListSecurityGroupsCmd) &&

!(cmdObj instanceof ListTagsCmd) && !(cmdObj instanceof ListEventsCmd) && !(cmdObj instanceof ListVMGroupsCmd) && !(cmdObj instanceof ListProjectsCmd) &&

!(cmdObj instanceof ListProjectAccountsCmd) && !(cmdObj instanceof ListProjectInvitationsCmd) && !(cmdObj instanceof ListHostsCmd) &&

!(cmdObj instanceof ListVolumesCmd) && !(cmdObj instanceof ListVolumesCmdByAdmin) && !(cmdObj instanceof ListUsersCmd) && !(cmdObj instanceof ListAccountsCmd)

&& !(cmdObj instanceof ListAccountsCmdByAdmin) &&

!(cmdObj instanceof ListStoragePoolsCmd) && !(cmdObj instanceof ListDiskOfferingsCmd) && !(cmdObj instanceof ListServiceOfferingsCmd) &&

!(cmdObj instanceof ListZonesCmd) && !(cmdObj instanceof ListZonesCmdByAdmin)) {

buildAsyncListResponse((BaseListCmd)cmdObj, caller);

}

SerializationContext.current().setUuidTranslation(true);

return ApiResponseSerializer.toSerializedStringWithSecureLogs((ResponseObject)cmdObj.getResponseObject(), cmdObj.getResponseType(), log);

}

}

@SuppressWarnings("unchecked")

private void buildAsyncListResponse(final BaseListCmd command, final Account account) {

final List<ResponseObject> responses = ((ListResponse)command.getResponseObject()).getResponses();

if (responses != null && responses.size() > 0) {

List<? extends AsyncJob> jobs = null;

// list all jobs for ROOT admin

if (accountMgr.isRootAdmin(account.getId())) {

jobs = asyncMgr.findInstancePendingAsyncJobs(command.getInstanceType().toString(), null);

} else {

jobs = asyncMgr.findInstancePendingAsyncJobs(command.getInstanceType().toString(), account.getId());

}

if (jobs.size() == 0) {

return;

}

final Map<String, AsyncJob> objectJobMap = new HashMap<String, AsyncJob>();

for (final AsyncJob job : jobs) {

if (job.getInstanceId() == null) {

continue;

}

final String instanceUuid = ApiDBUtils.findJobInstanceUuid(job);

objectJobMap.put(instanceUuid, job);

}

for (final ResponseObject response : responses) {

if (response.getObjectId() != null && objectJobMap.containsKey(response.getObjectId())) {

final AsyncJob job = objectJobMap.get(response.getObjectId());

response.setJobId(job.getUuid());

response.setJobStatus(job.getStatus().ordinal());

}

}

}

}

private void buildAuditTrail(final StringBuilder auditTrailSb, final String command, final String result) {

if (result == null) {

return;

}

auditTrailSb.append(" " + HttpServletResponse.SC_OK + " ");

if (command.equals("createSSHKeyPair")) {

auditTrailSb.append("This result was not logged because it contains sensitive data.");

} else {

auditTrailSb.append(result);

}

}

@Override

public boolean verifyRequest(final Map<String, Object[]> requestParameters, final Long userId) throws ServerApiException {

try {

String apiKey = null;

String secretKey = null;

String signature = null;

String unsignedRequest = null;

final String[] command = (String[])requestParameters.get(ApiConstants.COMMAND);

if (command == null) {

s_logger.info("missing command, ignoring request...");

return false;

}

final String commandName = command[0];

// if userId not null, that mean that user is logged in

if (userId != null) {

final User user = ApiDBUtils.findUserById(userId);

try {

checkCommandAvailable(user, commandName);

} catch (final RequestLimitException ex) {

s_logger.debug(ex.getMessage());

throw new ServerApiException(ApiErrorCode.API_LIMIT_EXCEED, ex.getMessage());

} catch (final PermissionDeniedException ex) {

s_logger.debug("The user with id:" + userId + " is not allowed to request the API command or the API command does not exist: " + commandName);

throw new ServerApiException(ApiErrorCode.UNSUPPORTED_ACTION_ERROR, "The user is not allowed to request the API command or the API command does not exist");

}

return true;

} else {

// check against every available command to see if the command exists or not

if (!s_apiNameCmdClassMap.containsKey(commandName) && !commandName.equals("login") && !commandName.equals("logout")) {

s_logger.debug("The user with id:" + userId + " is not allowed to request the API command or the API command does not exist: " + commandName);

throw new ServerApiException(ApiErrorCode.UNSUPPORTED_ACTION_ERROR, "The user is not allowed to request the API command or the API command does not exist");

}

}

// - build a request string with sorted params, make sure it's all lowercase

// - sign the request, verify the signature is the same

final List<String> parameterNames = new ArrayList<String>();

for (final Object paramNameObj : requestParameters.keySet()) {

parameterNames.add((String)paramNameObj); // put the name in a list that we'll sort later

}

Collections.sort(parameterNames);

String signatureVersion = null;

String expires = null;

for (final String paramName : parameterNames) {

// parameters come as name/value pairs in the form String/String[]

final String paramValue = ((String[])requestParameters.get(paramName))[0];

if (ApiConstants.SIGNATURE.equalsIgnoreCase(paramName)) {

signature = paramValue;

} else {

if (ApiConstants.API_KEY.equalsIgnoreCase(paramName)) {

apiKey = paramValue;

} else if (ApiConstants.SIGNATURE_VERSION.equalsIgnoreCase(paramName)) {

signatureVersion = paramValue;

} else if (ApiConstants.EXPIRES.equalsIgnoreCase(paramName)) {

expires = paramValue;

}

if (unsignedRequest == null) {

unsignedRequest = paramName + "=" + URLEncoder.encode(paramValue, HttpUtils.UTF_8).replaceAll("\\+", "%20");

} else {

unsignedRequest = unsignedRequest + "&" + paramName + "=" + URLEncoder.encode(paramValue, HttpUtils.UTF_8).replaceAll("\\+", "%20");

}

}

}

// if api/secret key are passed to the parameters

if ((signature == null) || (apiKey == null)) {

s_logger.debug("Expired session, missing signature, or missing apiKey -- ignoring request. Signature: " + signature + ", apiKey: " + apiKey);

return false; // no signature, bad request

}

Date expiresTS = null;

// FIXME: Hard coded signature, why not have an enum

if ("3".equals(signatureVersion)) {

// New signature authentication. Check for expire parameter and its validity

if (expires == null) {

s_logger.debug("Missing Expires parameter -- ignoring request. Signature: " + signature + ", apiKey: " + apiKey);

return false;

}

synchronized (DateFormatToUse) {

try {

expiresTS = DateFormatToUse.parse(expires);

} catch (final ParseException pe) {

s_logger.debug("Incorrect date format for Expires parameter", pe);

return false;

}

}

final Date now = new Date(System.currentTimeMillis());

if (expiresTS.before(now)) {

s_logger.debug("Request expired -- ignoring ...sig: " + signature + ", apiKey: " + apiKey);

return false;

}

}

final TransactionLegacy txn = TransactionLegacy.open(TransactionLegacy.CLOUD_DB);

txn.close();

User user = null;

// verify there is a user with this api key

final Pair<User, Account> 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();

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() +

"; accountState: " + account.getState());

return false;

}

try {

checkCommandAvailable(user, commandName);

} catch (final RequestLimitException ex) {

s_logger.debug(ex.getMessage());

throw new ServerApiException(ApiErrorCode.API_LIMIT_EXCEED, ex.getMessage());

} 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);

}

// verify secret key exists

secretKey = user.getSecretKey();

if (secretKey == null) {

s_logger.info("User does not have a secret key associated with the account -- ignoring request, username: " + user.getUsername());

return false;

}

unsignedRequest = unsignedRequest.toLowerCase();

final Mac mac = Mac.getInstance("HmacSHA1");

final SecretKeySpec keySpec = new SecretKeySpec(secretKey.getBytes(), "HmacSHA1");

mac.init(keySpec);

mac.update(unsignedRequest.getBytes());

final byte[] encryptedBytes = mac.doFinal();

final String computedSignature = Base64.encodeBase64String(encryptedBytes);

final boolean equalSig = ConstantTimeComparator.compareStrings(signature, computedSignature);

if (!equalSig) {

s_logger.info("User signature: " + signature + " is not equaled to computed signature: " + computedSignature);

} else {

CallContext.register(user, account);

}

return equalSig;

} catch (final ServerApiException ex) {

throw ex;

} catch (final Exception ex) {

s_logger.error("unable to verify request signature");

}

return false;

}

@Override

public Long fetchDomainId(final String domainUUID) {

final Domain domain = domainMgr.getDomain(domainUUID);

if (domain != null)

return domain.getId();

else

return null;

}

private ResponseObject createLoginResponse(HttpSession session) {

LoginCmdResponse response = new LoginCmdResponse();

response.setTimeout(session.getMaxInactiveInterval());

final String user_UUID = (String)session.getAttribute("user_UUID");

response.setUserId(user_UUID);

final String domain_UUID = (String)session.getAttribute("domain_UUID");

response.setDomainId(domain_UUID);

synchronized (session) {

session.removeAttribute("user_UUID");

session.removeAttribute("domain_UUID");

}

final Enumeration attrNames = session.getAttributeNames();

if (attrNames != null) {

while (attrNames.hasMoreElements()) {

final String attrName = (String) attrNames.nextElement();

final Object attrObj = session.getAttribute(attrName);

if (ApiConstants.USERNAME.equalsIgnoreCase(attrName)) {

response.setUsername(attrObj.toString());

}

if (ApiConstants.ACCOUNT.equalsIgnoreCase(attrName)) {

response.setAccount(attrObj.toString());

}

if (ApiConstants.FIRSTNAME.equalsIgnoreCase(attrName)) {

response.setFirstName(attrObj.toString());

}

if (ApiConstants.LASTNAME.equalsIgnoreCase(attrName)) {