CloudStackApi.java

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

import java.util.List;

import org.apache.log4j.Logger;

import com.cloud.stack.models.ApiConstants;
import com.cloud.stack.models.CloudStackAccount;
import com.cloud.stack.models.CloudStackCapabilities;
import com.cloud.stack.models.CloudStackDiskOffering;
import com.cloud.stack.models.CloudStackEvent;
import com.cloud.stack.models.CloudStackEventType;
import com.cloud.stack.models.CloudStackExtractTemplate;
import com.cloud.stack.models.CloudStackIdentifier;
import com.cloud.stack.models.CloudStackInfoResponse;
import com.cloud.stack.models.CloudStackInstanceGroup;
import com.cloud.stack.models.CloudStackIpAddress;
import com.cloud.stack.models.CloudStackKeyPair;
import com.cloud.stack.models.CloudStackKeyValue;
import com.cloud.stack.models.CloudStackLoadBalancerRule;
import com.cloud.stack.models.CloudStackNetwork;
import com.cloud.stack.models.CloudStackNetworkOffering;
import com.cloud.stack.models.CloudStackOsCategory;
import com.cloud.stack.models.CloudStackOsType;
import com.cloud.stack.models.CloudStackPasswordData;
import com.cloud.stack.models.CloudStackPortForwardingRule;
import com.cloud.stack.models.CloudStackResourceLimit;
import com.cloud.stack.models.CloudStackResourceTag;
import com.cloud.stack.models.CloudStackSecurityGroup;
import com.cloud.stack.models.CloudStackSecurityGroupIngress;
import com.cloud.stack.models.CloudStackServiceOffering;
import com.cloud.stack.models.CloudStackSnapshot;
import com.cloud.stack.models.CloudStackSnapshotPolicy;
import com.cloud.stack.models.CloudStackTemplate;
import com.cloud.stack.models.CloudStackTemplatePermission;
import com.cloud.stack.models.CloudStackUserVm;
import com.cloud.stack.models.CloudStackVolume;
import com.cloud.stack.models.CloudStackZone;
import com.google.gson.reflect.TypeToken;

/**
 * The goal here is to wrap the actual CloudStack API calls...
 * 
 *
 */
public class CloudStackApi {
	protected final static Logger logger = Logger.getLogger(CloudStackApi.class);
	
	private CloudStackClient _client;
	
	private String apiKey;
	private String secretKey;
	
	/**
	 * 
	 */
	public CloudStackApi(String cloudStackServiceHost, String port, Boolean bSslEnabled) {
		if (port != null) {
		    // initialize port to 8080, incase port is NULL
		    int ourPort = 8080;
		    if (port != null) 
		        ourPort = Integer.parseInt(port);
			_client = new CloudStackClient(cloudStackServiceHost, ourPort, bSslEnabled);
		} else {
			_client = new CloudStackClient(cloudStackServiceHost);
		}
		apiKey = null;
		secretKey = null;
	}

	/**
	 * @return the apiKey
	 */
	public String getApiKey() {
		return apiKey;
	}

	/**
	 * @return the secretKey
	 */
	public String getSecretKey() {
		return secretKey;
	}

	/**
	 * @param apiKey the apiKey to set
	 */
	public void setApiKey(String apiKey) {
		this.apiKey = apiKey;
	}

	/**
	 * @param secretKey the secretKey to set
	 */
	public void setSecretKey(String secretKey) {
		this.secretKey = secretKey;
	}
	
	
	// Virtual Machines

	/**
	 * deploy a virtual machine
	 * 
	 * @param serviceOfferingId
	 * @param templateId
	 * @param zoneId
	 * @param account
	 * @param diskOfferingId
	 * @param displayName
	 * @param domainId
	 * @param group
	 * @param hostId
	 * @param hypervisor
	 * @param keyPair
	 * @param name
	 * @param networkId
	 * @param securityGroupIds
	 * @param securityGroupNames
	 * @param size
	 * @param userData
	 * @return
	 * @throws Exception
	 */
	public CloudStackUserVm deployVirtualMachine(String serviceOfferingId, String templateId, String zoneId, String account, String diskOfferingId, 
			String displayName, String domainId, String group, String hostId, String hypervisor, String keyPair, String name, String networkId, 
			String securityGroupIds, String securityGroupNames, Long size, String userData) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DEPLOY_VIRTUAL_MACHINE);
		if (cmd != null) {
			// these are required
			cmd.setParam(ApiConstants.SERVICE_OFFERING_ID, serviceOfferingId);
			cmd.setParam(ApiConstants.TEMPLATE_ID, templateId);
			cmd.setParam(ApiConstants.ZONE_ID, zoneId);
			// these aren't
			if (account != null) cmd.setParam(ApiConstants.ACCOUNT, account);
			if (diskOfferingId != null) cmd.setParam(ApiConstants.DISK_OFFERING_ID, diskOfferingId);
			if (displayName != null) cmd.setParam(ApiConstants.DISPLAY_NAME, displayName);
			if (domainId != null) cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
			if (group != null) cmd.setParam(ApiConstants.GROUP, group);
			if (hostId != null) cmd.setParam(ApiConstants.HOST_ID, hostId);
			if (hypervisor != null) cmd.setParam(ApiConstants.HYPERVISOR, hypervisor);
			if (keyPair != null) cmd.setParam(ApiConstants.SSH_KEYPAIR, keyPair);
			if (name != null) cmd.setParam(ApiConstants.NAME, name);
			if (networkId != null) cmd.setParam(ApiConstants.NETWORK_IDS, networkId);
			if (securityGroupIds != null) cmd.setParam(ApiConstants.SECURITY_GROUP_IDS, securityGroupIds);
			if (securityGroupNames != null) cmd.setParam(ApiConstants.SECURITY_GROUP_NAMES, securityGroupNames);
			if (size != null) cmd.setParam(ApiConstants.SIZE, size.toString());
			if (userData != null) cmd.setParam(ApiConstants.USER_DATA, userData);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DEPLOY_VIRTUAL_MACHINE_RESPONSE, 
				ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
		
	}
	
	/**
	 * destroy's a virtual machine
	 * 
	 * @param id
	 * @return
	 * @throws Exception
	 */
	public CloudStackUserVm destroyVirtualMachine(String id) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DESTROY_VIRTUAL_MACHINE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DESTROY_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, 
				CloudStackUserVm.class);
	}
	
	/**
	 * reboot a virtual machine
	 * 
	 * @param id
	 * @return
	 * @throws Exception
	 */
	public CloudStackUserVm rebootVirtualMachine(String id) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.REBOOT_VIRTUAL_MACHINE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.REBOOT_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, 
				CloudStackUserVm.class);
	}
	
	/**
	 * start a virtual machine
	 * 
	 * @param id
	 * @return
	 * @throws Exception
	 */
	public CloudStackUserVm startVirtualMachine(String id) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.START_VIRTUAL_MACHINE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.START_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
	}

	/**
	 * stop a virtual machine
	 * 
	 * @param id
	 * @param forced
	 * @return
	 * @throws Exception
	 */
	public CloudStackUserVm stopVirtualMachine(String id, Boolean forced) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.STOP_VIRTUAL_MACHINE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			if (forced != null) cmd.setParam(ApiConstants.FORCED, forced.toString());
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.STOP_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
	}
	
	/**
	 * reset password for virtual machine
	 * 
	 * @param id
	 * @return
	 * @throws Exception
	 */
	public CloudStackUserVm resetPasswordForVirtualMachine(String id) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.RESET_PASSWORD_FOR_VIRTUAL_MACHINE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.RESET_PASSWORD_FOR_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
	}
	
	/**
	 * change service for virtual machine
	 * 
	 * @param id
	 * @param serviceOfferingId
	 * @return
	 * @throws Exception
	 */
	public CloudStackUserVm changeServiceForVirtualMachine(String id, String serviceOfferingId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CHANGE_SERVICE_FOR_VIRTUAL_MACHINE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			cmd.setParam(ApiConstants.SERVICE_OFFERING_ID, serviceOfferingId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CHANGE_SERVICE_FOR_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
	}
	
	/**
	 * update a virtual machine
	 * 
	 * @param id
	 * @param displayName
	 * @param group
	 * @param haEnable
	 * @param osTypeId
	 * @param userData
	 * @return
	 * @throws Exception
	 */
	public CloudStackUserVm updateVirtualMachine(String id, String displayName, String group, Boolean haEnable, String osTypeId, String userData) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_VIRTUAL_MACHINE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			if (displayName != null) cmd.setParam(ApiConstants.DISPLAY_NAME, displayName);
			if (group != null) cmd.setParam(ApiConstants.GROUP, group);
			if (haEnable != null) cmd.setParam(ApiConstants.HA_ENABLE, haEnable.toString());
			if (osTypeId != null) cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
			if (userData != null) cmd.setParam(ApiConstants.USER_DATA, userData);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.UPDATE_VIRTUAL_MACHINE_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
		
	}
	
	/**
	 * list virtual machines
	 * 
	 * @param account
	 * @param accountId
	 * @param forVirtualNetwork
	 * @param groupId
	 * @param hostId
	 * @param hypervisor
	 * @param id
	 * @param isRecursive
	 * @param keyWord
	 * @param name
	 * @param networkId
	 * @param podId
	 * @param state
	 * @param storageId
	 * @param zoneId
	 * @return
	 * @throws Exception
	 */
    public List<CloudStackUserVm> listVirtualMachines(String account, String accountId, Boolean listAll, Boolean forVirtualNetwork, String groupId, String hostId,
			String hypervisor, String id, Boolean isRecursive, String keyWord, String name, String networkId, String podId, String state, String storageId, 
            String zoneId, List<CloudStackKeyValue> resourceTags) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_VIRTUAL_MACHINES);
		if (cmd != null) {
			if (account != null) cmd.setParam(ApiConstants.ACCOUNT, account);
			if (accountId != null) cmd.setParam(ApiConstants.ACCOUNT_ID, accountId);
            if (listAll != null) cmd.setParam(ApiConstants.LIST_ALL, listAll.toString());
			if (forVirtualNetwork != null) cmd.setParam(ApiConstants.FOR_VIRTUAL_NETWORK, forVirtualNetwork.toString());
			if (groupId != null) cmd.setParam(ApiConstants.GROUP_ID, groupId);
			if (hostId != null) cmd.setParam(ApiConstants.HOST_ID, hostId);
			if (hypervisor != null) cmd.setParam(ApiConstants.HYPERVISOR, hypervisor);
			if (id != null) cmd.setParam(ApiConstants.ID, id);
			if (isRecursive != null) cmd.setParam(ApiConstants.IS_RECURSIVE, isRecursive.toString());
			if (keyWord != null) cmd.setParam(ApiConstants.KEYWORD, keyWord);
			if (name != null) cmd.setParam(ApiConstants.NAME, name);
			if (networkId != null) cmd.setParam(ApiConstants.NETWORK_ID, networkId);
			if (podId != null) cmd.setParam(ApiConstants.POD_ID, podId);
			if (state != null) cmd.setParam(ApiConstants.STATE, state);
			if (storageId != null) cmd.setParam(ApiConstants.STORAGE_ID, storageId);
			if (zoneId != null) cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            if (resourceTags != null && resourceTags.size() > 0)
                cmd = setParams(cmd, null, null, resourceTags);
		}
		return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_VIRTUAL_MACHINES_RESPONSE, ApiConstants.VIRTUAL_MACHINE, 
				new TypeToken<List<CloudStackUserVm>>() {}.getType());
	}

	/**
	 * get password from virtual machine
	 * 
	 * @param id
	 * @return
	 * @throws Exception
	 */
	public CloudStackPasswordData getVMPassword(String id) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.GET_VM_PASSWORD);
		if (cmd != null) 
			cmd.setParam(ApiConstants.ID, id);
		// TODO: This probably isn't right.  Need to test with an instance that has a VM Password  
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.GET_VM_PASSWORD_RESPONSE, ApiConstants.PASSWORD, CloudStackPasswordData.class);
	}
	
	// Templates
//<a href="user/createTemplate.html">createTemplate (A)</a>
	/**
	 * create a Template
	 * 
	 * @param displayText
	 * @param name
	 * @param osTypeId
	 * @param bits
	 * @param isFeatured
	 * @param isPublic
	 * @param passwordEnabled
	 * @param requiresHVM
	 * @param snapshotId
	 * @param volumeId
	 * @return
	 * @throws Exception
	 */
	public CloudStackTemplate createTemplate(String displayText, String name, String osTypeId, String bits, Boolean isFeatured, 
			Boolean isPublic, Boolean passwordEnabled, Boolean requiresHVM, String snapshotId, String volumeId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_TEMPLATE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
			cmd.setParam(ApiConstants.NAME, name);
			cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
			if (bits != null) cmd.setParam(ApiConstants.BITS, bits);
			if (isFeatured != null) cmd.setParam(ApiConstants.IS_FEATURED, isFeatured.toString());
			if (isPublic != null) cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
			if (passwordEnabled != null) cmd.setParam(ApiConstants.PASSWORD_ENABLED, passwordEnabled.toString());
			if (requiresHVM != null) cmd.setParam(ApiConstants.REQUIRES_HVM, requiresHVM.toString());
			if (snapshotId != null) cmd.setParam(ApiConstants.SNAPSHOT_ID, snapshotId);
			if (volumeId != null) cmd.setParam(ApiConstants.VOLUME_ID, volumeId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_TEMPLATE_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
	}
	
	/**
	 * register a template
	 * 
	 * @param displayText
	 * @param format
	 * @param hypervisor
	 * @param name
	 * @param osTypeId
	 * @param url
	 * @param zoneId
	 * @param account
	 * @param bits
	 * @param checksum
	 * @param domainId
	 * @param isExtractable
	 * @param isFeatured
	 * @param isPublic
	 * @param passwordEnabled
	 * @param requiresHVM
	 * @return
	 * @throws Exception
	 */
	public List<CloudStackTemplate> registerTemplate(String displayText, String format, String hypervisor, String name, String osTypeId, String url, 
			String zoneId, String account, String bits, String checksum, String domainId, Boolean isExtractable, Boolean isFeatured, Boolean isPublic,
			Boolean passwordEnabled, Boolean requiresHVM) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.REGISTER_TEMPLATE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
			cmd.setParam(ApiConstants.FORMAT, format);
			cmd.setParam(ApiConstants.HYPERVISOR, hypervisor);
			cmd.setParam(ApiConstants.NAME, name);
			cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
			cmd.setParam(ApiConstants.URL, url);
			cmd.setParam(ApiConstants.ZONE_ID, zoneId);
			if (account != null) cmd.setParam(ApiConstants.ACCOUNT, account);
			if (bits != null) cmd.setParam(ApiConstants.BITS, bits);
			if (checksum != null) cmd.setParam(ApiConstants.CHECKSUM, checksum);
			if (domainId != null) cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
			if (isExtractable != null) cmd.setParam(ApiConstants.IS_EXTRACTABLE, isExtractable.toString());
			if (isFeatured != null) cmd.setParam(ApiConstants.IS_FEATURED, isFeatured.toString());
			if (isPublic != null) cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
			if (passwordEnabled != null) cmd.setParam(ApiConstants.PASSWORD_ENABLED, passwordEnabled.toString());
			if (requiresHVM != null) cmd.setParam(ApiConstants.REQUIRES_HVM, requiresHVM.toString());
		}
		return _client.listCall(cmd, apiKey, secretKey, ApiConstants.REGISTER_TEMPLATE_RESPONSE, ApiConstants.TEMPLATE, new TypeToken<List<CloudStackTemplate>>() {}.getType());
	}
	
	/**
	 * update's a template
	 * 
	 * @param id
	 * @param bootable
	 * @param displayText
	 * @param format
	 * @param name
	 * @param osTypeId
	 * @param passwordEnabled
	 * @return
	 * @throws Exception
	 */
	public CloudStackTemplate updateTemplate(String id, Boolean bootable, String displayText, String format, String name, String osTypeId, 
			Boolean passwordEnabled) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_TEMPLATE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			if (bootable != null) cmd.setParam(ApiConstants.BOOTABLE, bootable.toString());
			if (displayText != null) cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
			if (format != null) cmd.setParam(ApiConstants.FORMAT, format);
			if (name != null) cmd.setParam(ApiConstants.NAME, name);
			if (osTypeId != null) cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
			if (passwordEnabled != null) cmd.setParam(ApiConstants.PASSWORD_ENABLED, passwordEnabled.toString());
		}
		return _client.call(cmd, apiKey, secretKey, false, ApiConstants.UPDATE_TEMPLATE_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
	}

	/**
	 * copy a template
	 * 
	 * @param id (required)
	 * @param destZoneId (required)
	 * @param sourceZoneId (required)
	 * @return
	 * @throws Exception
	 */
	public CloudStackTemplate copyTemplate(String id, String destZoneId, String sourceZoneId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.COPY_TEMPLATE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			cmd.setParam(ApiConstants.DESTINATION_ZONE_ID, destZoneId);
			cmd.setParam(ApiConstants.SOURCE_ZONE_ID, sourceZoneId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.COPY_TEMPLATE_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
	}

	/**
	 * Deletes a template from the system. All virtual machines using the deleted template will not be affected.
	 * 
	 * @param id (required)
	 * @param zoneId
	 * @return
	 * @throws Exception
	 */
	public CloudStackInfoResponse deleteTemplate(String id, String zoneId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_TEMPLATE);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			if (zoneId != null) cmd.setParam(ApiConstants.ZONE_ID, zoneId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_TEMPLATE_RESPONSE, null, CloudStackInfoResponse.class);
	}

	/**
	 * List all public, private, and privileged templates
	 * 
	 * @param templateFilter (required)
	 * @param account
	 * @param domainId
	 * @param hypervisor
	 * @param id
	 * @param keyWord
	 * @param name
	 * @param zoneId
	 * @return
	 * @throws Exception
	 */
	public List<CloudStackTemplate> listTemplates(String templateFilter, String account, String domainId, String hypervisor, String id, 
			String keyWord, String name, String zoneId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_TEMPLATES);
		if (cmd != null) {
			cmd.setParam(ApiConstants.TEMPLATE_FILTER, templateFilter);
			if (account != null) cmd.setParam(ApiConstants.ACCOUNT, account);
			if (domainId != null) cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
			if (hypervisor != null) cmd.setParam(ApiConstants.HYPERVISOR, hypervisor);
			if (id != null) cmd.setParam(ApiConstants.ID, id);
			if (keyWord != null) cmd.setParam(ApiConstants.KEYWORD, keyWord);
			if (name != null) cmd.setParam(ApiConstants.NAME, name);
			if (zoneId != null) cmd.setParam(ApiConstants.ZONE_ID, zoneId);
		}
		return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_TEMPLATES_RESPONSE, ApiConstants.TEMPLATE, 
				new TypeToken<List<CloudStackTemplate>>() {}.getType());
	}
	
	/**
	 * Updates a template visibility permissions. A public template is visible to all accounts within the same domain. 
	 * A private template is visible only to the owner of the template. A priviledged template is a private template with account 
	 * permissions added. Only accounts specified under the template permissions are visible to them.
	 * 
	 * @param id
	 * @param accounts
	 * @param isExtractable
	 * @param isFeatured
	 * @param isPublic
	 * @param op
	 * @return
	 * @throws Exception
	 */
	public CloudStackInfoResponse updateTemplatePermissions(String id, String accounts, Boolean isExtractable, Boolean isFeatured, Boolean isPublic, 
			String op) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_TEMPLATE_PERMISSIONS);
		if (cmd  != null) {
			cmd.setParam(ApiConstants.ID, id);
			if (accounts != null) cmd.setParam(ApiConstants.ACCOUNTS, accounts);
			if (isExtractable != null) cmd.setParam(ApiConstants.IS_EXTRACTABLE, isExtractable.toString());
			if (isFeatured != null) cmd.setParam(ApiConstants.IS_FEATURED, isFeatured.toString());
			if (isPublic != null) cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
			if (op != null) cmd.setParam(ApiConstants.OP, op);
		}
		return _client.call(cmd, apiKey, secretKey, false, ApiConstants.UPDATE_TEMPLATE_PERMISSIONS_RESPONSE, null, CloudStackInfoResponse.class);
	}
	
	/**
	 * List template visibility and all accounts that have permissions to view this template.
	 * 
	 * @param id
	 * @param account
	 * @param domainId
	 * @return
	 * @throws Exception
	 */
	public CloudStackTemplatePermission listTemplatePermissions(String id, String account, String domainId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_TEMPLATE_PERMISSIONS);
		if (cmd  != null) {
			cmd.setParam(ApiConstants.ID, id);
			if (account != null) cmd.setParam(ApiConstants.ACCOUNT, account);
			if (domainId != null) cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
		}
        return _client.call(cmd, apiKey, secretKey, false, ApiConstants.LIST_TEMPLATE_PERMISSIONS_RESPONSE, ApiConstants.TEMPLATE_PERMISSION, 
                CloudStackTemplatePermission.class);
	}

	/**
	 * Extracts a template
	 * 
	 * @param id
	 * @param mode
	 * @param zoneId
	 * @param url
	 * @return
	 * @throws Exception
	 */
	public CloudStackExtractTemplate extractTemplate(String id, String mode, String zoneId, String url) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.EXTRACT_TEMPLATE);
		if (cmd  != null) {
			cmd.setParam(ApiConstants.ID, id);
			cmd.setParam(ApiConstants.MODE, mode);
			cmd.setParam(ApiConstants.ZONE_ID, zoneId);
			if (url != null) cmd.setParam(ApiConstants.URL, url);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.EXTRACT_TEMPLATE_RESPONSE, null, CloudStackExtractTemplate.class);
	}
	
	// ISO's 
	/**
	 * Attaches an ISO to a virtual machine
	 * 
	 * @param id
	 * @param virtualMachineId
	 * @return
	 * @throws Exception
	 */
	public CloudStackUserVm attachIso(String id, String virtualMachineId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.ATTACH_ISO);
		if (cmd  != null) {
			cmd.setParam(ApiConstants.ID, id);
			cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.ATTACH_ISO_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
	}
	
	/**
	 * Detaches any ISO file (if any) currently attached to a virtual machine.
	 * 
	 * @param virtualMachineId
	 * @return
	 * @throws Exception
	 */
	public CloudStackUserVm detachIso(String virtualMachineId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DETACH_ISO);
		if (cmd != null) {
			cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DETACH_ISO_RESPONSE, ApiConstants.VIRTUAL_MACHINE, CloudStackUserVm.class);
	}

	/**
	 * Lists all available ISO files.
	 * 
	 * @param account
	 * @param bootable
	 * @param domainId
	 * @param hypervisor
	 * @param id
	 * @param isoFilter
	 * @param isPublic
	 * @param isReady
	 * @param keyWord
	 * @param name
	 * @param zoneId
	 * @return
	 * @throws Exception
	 */
	public List<CloudStackTemplate> listIsos(String account, Boolean bootable, String domainId, String hypervisor, String id, String isoFilter, 
			Boolean isPublic, Boolean isReady, String keyWord, String name, String zoneId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_ISOS);
		if (cmd != null) {
			if (account != null) cmd.setParam(ApiConstants.ACCOUNT, account);
			if (bootable != null) cmd.setParam(ApiConstants.BOOTABLE, bootable.toString());
			if (domainId != null) cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
			if (hypervisor != null) cmd.setParam(ApiConstants.HYPERVISOR, hypervisor);
			if (id != null) cmd.setParam(ApiConstants.ID, id);
			if (isoFilter != null) cmd.setParam(ApiConstants.ISO_FILTER, isoFilter);
			if (isPublic != null) cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
			if (isReady != null) cmd.setParam(ApiConstants.IS_READY, isReady.toString());
			if (keyWord != null) cmd.setParam(ApiConstants.KEYWORD, keyWord);
			if (name != null) cmd.setParam(ApiConstants.NAME, name);
			if (zoneId != null) cmd.setParam(ApiConstants.ZONE_ID, zoneId);
		}
		return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_ISOS_RESPONSE, ApiConstants.TEMPLATE, 
				new TypeToken<List<CloudStackTemplate>>() {}.getType());
	}
	
	/**
	 * Registers an existing ISO into the Cloud.com Cloud.
	 * 
	 * @param displayText
	 * @param name
	 * @param url
	 * @param zoneId
	 * @param account
	 * @param bootable
	 * @param domainId
	 * @param isExtractable
	 * @param isFeatured
	 * @param isPublic
	 * @param osTypeId
	 * @return
	 * @throws Exception
	 */
	public CloudStackTemplate registerIso(String displayText, String name, String url, String zoneId, String account, Boolean bootable, String domainId, 
			Boolean isExtractable, Boolean isFeatured, Boolean isPublic, String osTypeId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.REGISTER_ISO);
		if (cmd != null) {
			cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
			cmd.setParam(ApiConstants.NAME, name);
			cmd.setParam(ApiConstants.URL, url);
			cmd.setParam(ApiConstants.ZONE_ID, zoneId);
			if (account != null) cmd.setParam(ApiConstants.ACCOUNT, account);
			if (bootable != null) cmd.setParam(ApiConstants.BOOTABLE, bootable.toString());
			if (domainId != null) cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
			if (isExtractable != null) cmd.setParam(ApiConstants.IS_EXTRACTABLE, isExtractable.toString());
			if (isFeatured != null) cmd.setParam(ApiConstants.IS_FEATURED, isFeatured.toString());
			if (isPublic != null) cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
			if (osTypeId != null) cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
		}
		return _client.call(cmd, apiKey, secretKey, false, ApiConstants.REGISTER_ISO_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
	}

	/**
	 * Updates an ISO
	 * 
	 * @param id
	 * @param bootable
	 * @param displayText
	 * @param format
	 * @param name
	 * @param osTypeId
	 * @param passwordEnabled
	 * @return
	 * @throws Exception
	 */
	public CloudStackTemplate updateIso(String id, Boolean bootable, String displayText, String format, String name, String osTypeId, 
			Boolean passwordEnabled) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_ISO);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			if (bootable != null) cmd.setParam(ApiConstants.BOOTABLE, bootable.toString());
			if (displayText != null) cmd.setParam(ApiConstants.DISPLAY_TEXT, displayText);
			if (format != null) cmd.setParam(ApiConstants.FORMAT, format);
			if (name != null) cmd.setParam(ApiConstants.NAME, name);
			if (osTypeId != null) cmd.setParam(ApiConstants.OS_TYPE_ID, osTypeId);
			if (passwordEnabled != null) cmd.setParam(ApiConstants.PASSWORD_ENABLED, passwordEnabled.toString());
		}
		return _client.call(cmd, apiKey, secretKey, false, ApiConstants.UPDATE_ISO_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
	}
	
	/**
	 * Deletes an ISO
	 * 
	 * @param id
	 * @param zoneId
	 * @return
	 * @throws Exception
	 */
	public CloudStackInfoResponse deleteIso(String id, String zoneId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_ISO);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			cmd.setParam(ApiConstants.ZONE_ID, zoneId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_ISO_RESPONSE, null, CloudStackInfoResponse.class);
	}

	/**
	 * Copies a template from one zone to another
	 * 
	 * @param id
	 * @param destZoneId
	 * @param sourceZoneId
	 * @return
	 * @throws Exception
	 */
	public CloudStackTemplate copyIso(String id, String destZoneId, String sourceZoneId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.COPY_ISO);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			cmd.setParam(ApiConstants.DESTINATION_ZONE_ID, destZoneId);
			cmd.setParam(ApiConstants.SOURCE_ZONE_ID, sourceZoneId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.COPY_ISO_RESPONSE, ApiConstants.TEMPLATE, CloudStackTemplate.class);
	}
	
	/**
	 * Updates ISO permissions
	 * 
	 * @param id
	 * @param accounts
	 * @param isExtractable
	 * @param isFeatured
	 * @param isPublic
	 * @param op
	 * @return
	 * @throws Exception
	 */
	public CloudStackInfoResponse updateIsoPermissions(String id, String accounts, Boolean isExtractable, Boolean isFeatured, 
			Boolean isPublic, String op) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.UPDATE_ISO_PERMISSIONS);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			if (accounts != null) cmd.setParam(ApiConstants.ACCOUNTS, accounts);
			if (isExtractable != null) cmd.setParam(ApiConstants.IS_EXTRACTABLE, isExtractable.toString());
			if (isFeatured != null) cmd.setParam(ApiConstants.IS_FEATURED, isFeatured.toString());
			if (isPublic != null) cmd.setParam(ApiConstants.IS_PUBLIC, isPublic.toString());
			if (op != null) cmd.setParam(ApiConstants.OP, op);
		}
		return _client.call(cmd, apiKey, secretKey, false, ApiConstants.UPDATE_ISO_PERMISSIONS_RESPONSE, null, CloudStackInfoResponse.class);
	}
	
	/**
	 * List template visibility and all accounts that have permissions to view this template
	 * @param id
	 * @param account
	 * @param domainId
	 * @return
	 * @throws Exception
	 */
	public List<CloudStackTemplatePermission> listIsoPermissions(String id, String account, String domainId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_ISO_PERMISSIONS);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			if (account != null) cmd.setParam(ApiConstants.ACCOUNT, account);
			if (domainId != null) cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
		}
		return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_ISO_PERMISSIONS_RESPONSE, ApiConstants.TEMPLATE, 
				new TypeToken<List<CloudStackTemplatePermission>>() {}.getType());
	}

	/**
	 * Extracts an iso 
	 * 
	 * @param id
	 * @param mode
	 * @param zoneId
	 * @param url
	 * @return
	 * @throws Exception
	 */
	public CloudStackExtractTemplate extractIso(String id, String mode, String zoneId, String url) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.EXTRACT_ISO);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			cmd.setParam(ApiConstants.MODE, mode);
			cmd.setParam(ApiConstants.ZONE_ID, zoneId);
			if (url != null) cmd.setParam(ApiConstants.URL, url);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.EXTRACT_ISO_RESPONSE, ApiConstants.TEMPLATE, CloudStackExtractTemplate.class);
	}
	
	// Volumes
	/**
	 * Attaches a disk volume to a virtual machine
	 * 
	 * @param id
	 * @param virtualMachineId
	 * @param deviceId
	 * @return
	 * @throws Exception
	 */
	public CloudStackVolume attachVolume(String id, String virtualMachineId, String deviceId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.ATTACH_VOLUME);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
			if (deviceId != null) cmd.setParam(ApiConstants.DEVICE_ID, deviceId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.ATTACH_VOLUME_RESPONSE, ApiConstants.VOLUME, CloudStackVolume.class);
	}

	/**
	 * Detaches a disk volume from a virtual machine
	 * 
	 * @param deviceId
	 * @param id
	 * @param virtualMachineId
	 * @return
	 * @throws Exception
	 */
	public CloudStackVolume detachVolume(String deviceId, String id, String virtualMachineId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DETACH_VOLUME);
		if (cmd != null) {
			if (deviceId != null) cmd.setParam(ApiConstants.DEVICE_ID, deviceId);
			if (id != null) cmd.setParam(ApiConstants.ID, id);
			if (virtualMachineId != null) cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DETACH_VOLUME_RESPONSE, ApiConstants.VOLUME, CloudStackVolume.class);
	}
	
	/**
	 * Creates a disk volume from a disk offering. This disk volume must still be attached to a virtual machine to make use of it
	 * 
	 * @param name
	 * @param account
	 * @param diskOfferingId
	 * @param domainId
	 * @param size
	 * @param snapshotId
	 * @param zoneId
	 * @return
	 * @throws Exception
	 */
	public CloudStackVolume createVolume(String name, String account, String diskOfferingId, String domainId, Long size, String snapshotId, 
			String zoneId) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_VOLUME);
		if (cmd != null) {
			cmd.setParam(ApiConstants.NAME, name);
			if (account != null) cmd.setParam(ApiConstants.ACCOUNT, account);
			if (diskOfferingId != null) cmd.setParam(ApiConstants.DISK_OFFERING_ID, diskOfferingId);
			if (domainId != null) cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
			if (size != null) cmd.setParam(ApiConstants.SIZE, size.toString());
			if (snapshotId != null) cmd.setParam(ApiConstants.SNAPSHOT_ID, snapshotId);
			if (zoneId != null) cmd.setParam(ApiConstants.ZONE_ID, zoneId);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_VOLUME_RESPONSE, ApiConstants.VOLUME, CloudStackVolume.class);
	}
	
	/**
	 * Deletes a detached disk volume
	 * 
	 * @param id
	 * @return
	 * @throws Exception
	 */
	public CloudStackInfoResponse deleteVolume(String id) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.DELETE_VOLUME);
		if (cmd != null)
			cmd.setParam(ApiConstants.ID, id);
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.DELETE_VOLUME_RESPONSE, null, CloudStackInfoResponse.class);
	}
	
	/**
	 * Lists all volumes
	 * 
	 * @param account
	 * @param domainId
	 * @param hostId
	 * @param id
	 * @param isRecursive
	 * @param keyWord
	 * @param name
	 * @param podId
	 * @param type
	 * @param virtualMachineId
	 * @param zoneId
	 * @return
	 * @throws Exception
	 */
	public List<CloudStackVolume> listVolumes(String account, String domainId, String hostId, String id, Boolean isRecursive, String keyWord, String name,
            String podId, String type, String virtualMachineId, String zoneId, List<CloudStackKeyValue> resourceTags) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.LIST_VOLUMES);
		if (cmd != null) {
			if (account != null) cmd.setParam(ApiConstants.ACCOUNT, account);
			if (domainId != null) cmd.setParam(ApiConstants.DOMAIN_ID, domainId);
			if (hostId != null) cmd.setParam(ApiConstants.HOST_ID, hostId);
			if (id != null) cmd.setParam(ApiConstants.ID, id);
			if (isRecursive != null) cmd.setParam(ApiConstants.IS_RECURSIVE, isRecursive.toString());
			if (keyWord != null) cmd.setParam(ApiConstants.KEYWORD, keyWord);
			if (name != null) cmd.setParam(ApiConstants.NAME, name);
			if (podId != null) cmd.setParam(ApiConstants.POD_ID, podId);
			if (type != null) cmd.setParam(ApiConstants.TYPE, type);
			if (virtualMachineId != null) cmd.setParam(ApiConstants.VIRTUAL_MACHINE_ID, virtualMachineId);
			if (zoneId != null) cmd.setParam(ApiConstants.ZONE_ID, zoneId);
            if (resourceTags != null && resourceTags.size() > 0)
                cmd = setParams(cmd, null, null, resourceTags);
		}
		return _client.listCall(cmd, apiKey, secretKey, ApiConstants.LIST_VOLUMES_RESPONSE, ApiConstants.VOLUME, 
				new TypeToken<List<CloudStackVolume>>() {}.getType());
	}

	/**
	 * Extracts volume
	 * 
	 * @param id
	 * @param mode
	 * @param zoneId
	 * @param url
	 * @return
	 * @throws Exception
	 */
	public CloudStackExtractTemplate extractVolume(String id, String mode, String zoneId, String url) throws Exception {
		CloudStackCommand cmd = new CloudStackCommand(ApiConstants.EXTRACT_VOLUME);
		if (cmd != null) {
			cmd.setParam(ApiConstants.ID, id);
			cmd.setParam(ApiConstants.MODE, mode);
			cmd.setParam(ApiConstants.ZONE_ID, zoneId);
			if (url != null) cmd.setParam(ApiConstants.URL, url);
		}
		return _client.call(cmd, apiKey, secretKey, true, ApiConstants.EXTRACT_VOLUME_RESPONSE, ApiConstants.VOLUME, CloudStackExtractTemplate.class);
	}

    //Tags
    /**
     * Create tags
     *
     * @param resource type
     * @param resource id's
     * @param tags
     * @return
     * @throws Exception
     *
     */
    public CloudStackInfoResponse createTags(String resourceType, List<String>resourceIds,
            List<CloudStackKeyValue> resourceTags) throws Exception {
        CloudStackCommand cmd = new CloudStackCommand(ApiConstants.CREATE_TAGS);
        cmd = setParams(cmd, resourceType, resourceIds, resourceTags);
        return _client.call(cmd, apiKey, secretKey, true, ApiConstants.CREATE_TAGS_RESPONSE,
                null, CloudStackInfoResponse.class);
    }