mirror of https://github.com/apache/cloudstack.git
225 lines
10 KiB
Java
225 lines
10 KiB
Java
/**
|
|
* Copyright (C) 2010 Cloud.com, Inc. All rights reserved.
|
|
*
|
|
* This software is licensed under the GNU General Public License v3 or later.
|
|
*
|
|
* It is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or any later version.
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
package com.cloud.api.commands;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import org.apache.log4j.Logger;
|
|
|
|
import com.cloud.api.BaseCmd;
|
|
import com.cloud.api.ServerApiException;
|
|
import com.cloud.async.executor.VolumeOperationResultObject;
|
|
import com.cloud.exception.InvalidParameterValueException;
|
|
import com.cloud.hypervisor.Hypervisor;
|
|
import com.cloud.serializer.SerializerHelper;
|
|
import com.cloud.storage.DiskOfferingVO;
|
|
import com.cloud.storage.Snapshot;
|
|
import com.cloud.user.Account;
|
|
import com.cloud.utils.Pair;
|
|
|
|
public class CreateVolumeCmd extends BaseCmd {
|
|
public static final Logger s_logger = Logger.getLogger(CreateVolumeCmd.class.getName());
|
|
private static final String s_name = "createvolumeresponse";
|
|
private static final List<Pair<Enum, Boolean>> s_properties = new ArrayList<Pair<Enum, Boolean>>();
|
|
|
|
static {
|
|
s_properties.add(new Pair<Enum, Boolean>(BaseCmd.Properties.ACCOUNT_OBJ, Boolean.FALSE));
|
|
s_properties.add(new Pair<Enum, Boolean>(BaseCmd.Properties.USER_ID, Boolean.FALSE));
|
|
s_properties.add(new Pair<Enum, Boolean>(BaseCmd.Properties.ACCOUNT, Boolean.FALSE));
|
|
s_properties.add(new Pair<Enum, Boolean>(BaseCmd.Properties.DOMAIN_ID, Boolean.FALSE));
|
|
s_properties.add(new Pair<Enum, Boolean>(BaseCmd.Properties.NAME, Boolean.TRUE));
|
|
s_properties.add(new Pair<Enum, Boolean>(BaseCmd.Properties.ZONE_ID, Boolean.FALSE));
|
|
s_properties.add(new Pair<Enum, Boolean>(BaseCmd.Properties.DISK_OFFERING_ID, Boolean.FALSE));
|
|
s_properties.add(new Pair<Enum, Boolean>(BaseCmd.Properties.SNAPSHOT_ID, Boolean.FALSE));
|
|
s_properties.add(new Pair<Enum, Boolean>(BaseCmd.Properties.SIZE, Boolean.FALSE));
|
|
}
|
|
|
|
public String getName() {
|
|
return s_name;
|
|
}
|
|
|
|
public static String getResultObjectName() {
|
|
return "volume";
|
|
}
|
|
|
|
public List<Pair<Enum, Boolean>> getProperties() {
|
|
return s_properties;
|
|
}
|
|
|
|
@Override
|
|
public List<Pair<String, Object>> execute(Map<String, Object> params) {
|
|
Account account = (Account) params.get(BaseCmd.Properties.ACCOUNT_OBJ.getName());
|
|
Long userId = (Long) params.get(BaseCmd.Properties.USER_ID.getName());
|
|
String accountName = (String) params.get(BaseCmd.Properties.ACCOUNT.getName());
|
|
Long domainId = (Long) params.get(BaseCmd.Properties.DOMAIN_ID.getName());
|
|
String name = (String) params.get(BaseCmd.Properties.NAME.getName());
|
|
Long zoneId = (Long) params.get(BaseCmd.Properties.ZONE_ID.getName());
|
|
Long diskOfferingId = (Long) params.get(BaseCmd.Properties.DISK_OFFERING_ID.getName());
|
|
Long snapshotId = (Long)params.get(BaseCmd.Properties.SNAPSHOT_ID.getName());
|
|
Long size = (Long)params.get(BaseCmd.Properties.SIZE.getName());
|
|
|
|
if (account == null) {
|
|
// Admin API call
|
|
|
|
// Check if accountName was passed in
|
|
if ((accountName == null) || (domainId == null)) {
|
|
throw new ServerApiException(BaseCmd.PARAM_ERROR, "Account and domainId must be passed in.");
|
|
}
|
|
|
|
// Look up the account by name and domain ID
|
|
account = getManagementServer().findActiveAccount(accountName, domainId);
|
|
|
|
// If the account is null, this means that the accountName and domainId passed in were invalid
|
|
if (account == null)
|
|
throw new ServerApiException(BaseCmd.PARAM_ERROR, "Unable to find account with name: " + accountName + " and domain ID: " + domainId);
|
|
} else {
|
|
// User API call
|
|
|
|
// If the account is an admin, and accountName/domainId were passed in, use the account specified by these parameters
|
|
if (isAdmin(account.getType())) {
|
|
if (domainId != null) {
|
|
if (!getManagementServer().isChildDomain(account.getDomainId(), domainId)) {
|
|
throw new ServerApiException(BaseCmd.ACCOUNT_ERROR, "Unable to create volume in domain " + domainId + ", permission denied.");
|
|
}
|
|
if (accountName != null) {
|
|
account = getManagementServer().findActiveAccount(accountName, domainId);
|
|
|
|
if (account == null)
|
|
throw new ServerApiException(BaseCmd.PARAM_ERROR, "Unable to find account with name: " + accountName + " and domain ID: " + domainId);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If command is executed via the Admin API, set userId to the id of System account (1)
|
|
if (userId == null) {
|
|
userId = Long.valueOf(Account.ACCOUNT_ID_SYSTEM);
|
|
}
|
|
|
|
if(size==null){
|
|
size = Long.valueOf(0);
|
|
}
|
|
|
|
if(diskOfferingId != null){
|
|
DiskOfferingVO dOffering = getManagementServer().findDiskOfferingById(diskOfferingId.longValue());
|
|
|
|
if(dOffering == null){
|
|
throw new ServerApiException(BaseCmd.PARAM_ERROR,"Diskoffering id:"+diskOfferingId+" is invalid");
|
|
}
|
|
}
|
|
|
|
boolean useSnapshot = false;
|
|
if (snapshotId == null)
|
|
{
|
|
if ((zoneId == null))
|
|
{
|
|
throw new ServerApiException(BaseCmd.PARAM_ERROR, "Missing parameter,zoneid must be specified.");
|
|
}
|
|
|
|
if(diskOfferingId == null && size == 0)
|
|
{
|
|
throw new ServerApiException(BaseCmd.PARAM_ERROR, "Missing parameter(s),either a positive volume size or a valid disk offering id must be specified.");
|
|
}
|
|
else if(diskOfferingId == null && size != 0)
|
|
{
|
|
//validate the size to ensure between min and max size range
|
|
try
|
|
{
|
|
boolean ok = getManagementServer().validateCustomVolumeSizeRange(size);
|
|
|
|
if(!ok)
|
|
throw new ServerApiException(BaseCmd.PARAM_ERROR, "Invalid size for custom volume creation:");
|
|
|
|
} catch (InvalidParameterValueException e)
|
|
{
|
|
s_logger.warn("Invalid size for custom volume creation");
|
|
throw new ServerApiException(BaseCmd.PARAM_ERROR, "Invalid size for custom volume creation:"+e.getMessage());
|
|
}
|
|
|
|
//this is the case of creating var size vol with private disk offering
|
|
List<DiskOfferingVO> privateTemplateList = getManagementServer().findPrivateDiskOffering();
|
|
diskOfferingId = privateTemplateList.get(0).getId(); //we use this id for creating volume, randomly tagging it to a pool with an offering
|
|
}
|
|
}
|
|
else
|
|
{
|
|
useSnapshot = true;
|
|
//Verify parameters
|
|
Snapshot snapshotCheck = getManagementServer().findSnapshotById(snapshotId);
|
|
if (snapshotCheck == null) {
|
|
throw new ServerApiException (BaseCmd.SNAPSHOT_INVALID_PARAM_ERROR, "unable to find a snapshot with id " + snapshotId);
|
|
}
|
|
|
|
if (account != null) {
|
|
if (isAdmin(account.getType())) {
|
|
Account snapshotOwner = getManagementServer().findAccountById(snapshotCheck.getAccountId());
|
|
if (!getManagementServer().isChildDomain(account.getDomainId(), snapshotOwner.getDomainId())) {
|
|
throw new ServerApiException(BaseCmd.ACCOUNT_ERROR, "Unable to create volume from snapshot with id " + snapshotId + ", permission denied.");
|
|
}
|
|
} else if (account.getId() != snapshotCheck.getAccountId()) {
|
|
throw new ServerApiException(BaseCmd.SNAPSHOT_INVALID_PARAM_ERROR, "unable to find a snapshot with id " + snapshotId + " for this account");
|
|
}
|
|
}
|
|
}
|
|
|
|
try {
|
|
long jobId = 0;
|
|
if (useSnapshot) {
|
|
jobId = getManagementServer().createVolumeFromSnapshotAsync(userId, account.getId(), snapshotId, name);
|
|
} else {
|
|
jobId = getManagementServer().createVolumeAsync(userId, account.getId(), name, zoneId, diskOfferingId, size);
|
|
}
|
|
|
|
if (jobId == 0) {
|
|
s_logger.warn("Unable to schedule async-job for CreateVolume command");
|
|
} else {
|
|
if(s_logger.isDebugEnabled())
|
|
s_logger.debug("CreateVolume command has been accepted, job id: " + jobId);
|
|
}
|
|
|
|
long volumeId = waitInstanceCreation(jobId);
|
|
|
|
List<Pair<String, Object>> returnValues = new ArrayList<Pair<String, Object>>();
|
|
returnValues.add(new Pair<String, Object>(BaseCmd.Properties.JOB_ID.getName(), Long.valueOf(jobId)));
|
|
returnValues.add(new Pair<String, Object>(BaseCmd.Properties.VOLUME_ID.getName(), Long.valueOf(volumeId)));
|
|
|
|
return returnValues;
|
|
} catch (Exception ex) {
|
|
s_logger.error("Failed to create volume " + (useSnapshot ? ("from snapshot " + snapshotId) : ("in zone " + zoneId + " with disk offering " + diskOfferingId)), ex);
|
|
if (useSnapshot) {
|
|
throw new ServerApiException(BaseCmd.CREATE_VOLUME_FROM_SNAPSHOT_ERROR, "Unable to create a volume from snapshot with id " + snapshotId + " for this account.");
|
|
} else {
|
|
throw new ServerApiException(BaseCmd.INTERNAL_ERROR, "Failed to create volume: " + ex.getMessage());
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
protected long getInstanceIdFromJobSuccessResult(String result) {
|
|
VolumeOperationResultObject resultObject = (VolumeOperationResultObject) SerializerHelper.fromSerializedString(result);
|
|
if(resultObject != null) {
|
|
return resultObject.getId();
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
}
|