Java tutorial
// // 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.storage.datastore.util; import com.cloud.agent.api.Answer; import com.cloud.utils.exception.CloudRuntimeException; import com.google.gson.Gson; import com.google.gson.annotations.SerializedName; import com.sun.jersey.api.client.Client; import com.sun.jersey.api.client.ClientResponse; import com.sun.jersey.api.client.WebResource; import com.sun.jersey.api.client.config.ClientConfig; import com.sun.jersey.api.client.config.DefaultClientConfig; import com.sun.jersey.core.util.MultivaluedMapImpl; import org.apache.cloudstack.framework.config.dao.ConfigurationDao; import org.apache.cloudstack.utils.security.SSLUtils; import org.apache.cloudstack.utils.security.SecureSSLSocketFactory; import org.apache.http.auth.InvalidCredentialsException; import org.apache.log4j.Logger; import javax.naming.ServiceUnavailableException; import javax.net.ssl.HostnameVerifier; import javax.net.ssl.HttpsURLConnection; import javax.net.ssl.SSLContext; import javax.net.ssl.SSLHandshakeException; import javax.net.ssl.SSLSession; import javax.net.ssl.TrustManager; import javax.net.ssl.X509TrustManager; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.MultivaluedMap; import javax.ws.rs.core.UriBuilder; import java.net.ConnectException; import java.security.InvalidParameterException; import java.security.SecureRandom; import java.security.cert.X509Certificate; import java.util.HashMap; public class ElastistorUtil { private static final Logger s_logger = Logger.getLogger(ElastistorUtil.class); private static ConfigurationDao configurationDao; public static ConfigurationDao getConfigurationDao() { return configurationDao; } public static void setConfigurationDao(ConfigurationDao configurationDao) { ElastistorUtil.configurationDao = configurationDao; } /** * Elastistor REST API Param Keys. These should match exactly with the * elastistor API commands' params. */ public static final String REST_PARAM_COMMAND = "command"; public static final String REST_PARAM_APIKEY = "apikey"; public static final String REST_PARAM_KEYWORD = "keyword"; public static final String REST_PARAM_ID = "id"; public static final String REST_PARAM_QUOTA_SIZE = "quotasize"; public static final String REST_PARAM_READONLY = "readonly"; public static final String REST_PARAM_RESPONSE = "response"; public static final String REST_PARAM_POOLID = "poolid"; public static final String REST_PARAM_ACCOUNTID = "accountid"; public static final String REST_PARAM_GATEWAY = "router"; public static final String REST_PARAM_SUBNET = "subnet"; public static final String REST_PARAM_INTERFACE = "tntinterface"; public static final String REST_PARAM_IPADDRESS = "ipaddress"; public static final String REST_PARAM_JOBID = "jobId"; public static final String REST_PARAM_FORECEDELETE = "forcedelete"; public static final String REST_PARAM_TSM_THROUGHPUT = "totalthroughput"; public static final String REST_PARAM_NAME = "name"; public static final String REST_PARAM_NOOFCOPIES = "noofcopies"; public static final String REST_PARAM_RECORDSIZE = "recordsize"; public static final String REST_PARAM_TOTALIOPS = "totaliops"; public static final String REST_PARAM_LATENCY = "latency"; public static final String REST_PARAM_BLOCKSIZE = "blocksize"; public static final String REST_PARAM_GRACEALLOWED = "graceallowed"; public static final String REST_PARAM_IOPS = "iops"; public static final String REST_PARAM_THROUGHPUT = "throughput"; public static final String REST_PARAM_MEMLIMIT = "memlimit"; public static final String REST_PARAM_NETWORKSPEED = "networkspeed"; public static final String REST_PARAM_TSMID = "tsmid"; public static final String REST_PARAM_DATASETID = "datasetid"; public static final String REST_PARAM_QOSGROUPID = "qosgroupid"; public static final String REST_PARAM_DEDUPLICATION = "deduplication"; public static final String REST_PARAM_COMPRESSION = "compression"; public static final String REST_PARAM_SYNC = "sync"; public static final String REST_PARAM_MOUNTPOINT = "mountpoint"; public static final String REST_PARAM_CASESENSITIVITY = "casesensitivity"; public static final String REST_PARAM_UNICODE = "unicode"; public static final String REST_PARAM_PROTOCOLTYPE = "protocoltype"; public static final String REST_PARAM_AUTHNETWORK = "authnetwork"; public static final String REST_PARAM_MAPUSERSTOROOT = "mapuserstoroot"; public static final String REST_PARAM_STORAGEID = "storageid"; public static final String REST_PARAM_TPCONTROL = "tpcontrol"; public static final String REST_PARAM_IOPSCONTROL = "iopscontrol"; /** * Constants related to elastistor which are persisted in cloudstack * databases as keys. */ public static final String ES_SUBNET = "essubnet"; public static final String ES_INTERFACE = "estntinterface"; public static final String ES_GATEWAY = "esdefaultgateway"; public static final String ES_PROVIDER_NAME = "CloudByte"; public static final String ES_ACCOUNT_ID = "esAccountId"; public static final String ES_POOL_ID = "esPoolId"; public static final String ES_ACCOUNT_NAME = "esAccountName"; public static final String ES_STORAGE_IP = "esStorageIp"; public static final String ES_STORAGE_PORT = "esStoragePort"; public static final String ES_STORAGE_TYPE = "esStorageType"; public static final String ES_MANAGEMENT_IP = "esMgmtIp"; public static final String ES_MANAGEMENT_PORT = "esMgmtPort"; public static final String ES_API_KEY = "esApiKey"; public static final String ES_VOLUME_ID = "esVolumeId"; public static final String ES_VOLUME_GROUP_ID = "esVolumeGroupId"; public static final String ES_FILE_SYSTEM_ID = "esFilesystemId"; /** * Values from configuration that are required for every invocation of * ElastiCenter API. These might in turn be saved as DB updates along with * above keys. */ public static String s_esIPVAL = ""; public static String s_esAPIKEYVAL = ""; public static String s_esACCOUNTIDVAL = ""; public static String s_esPOOLIDVAL = ""; public static String s_esSUBNETVAL = ""; public static String s_esINTERFACEVAL = ""; public static String s_esGATEWAYVAL = ""; /** * hardcoded constants for elastistor api calls. */ private static final String ES_NOOFCOPIES_VAL = "1"; private static final String ES_BLOCKSIZE_VAL = "4K"; private static final String ES_LATENCY_VAL = "15"; private static final String ES_GRACEALLOWED_VAL = "false"; private static final String ES_MEMLIMIT_VAL = "0"; private static final String ES_NETWORKSPEED_VAL = "0"; private static final String ES_DEDUPLICATION_VAL = "off"; private static final String ES_COMPRESSION_VAL = "off"; private static final String ES_CASESENSITIVITY_VAL = "sensitive"; private static final String ES_READONLY_VAL = "off"; private static final String ES_UNICODE_VAL = "off"; private static final String ES_AUTHNETWORK_VAL = "all"; private static final String ES_MAPUSERSTOROOT_VAL = "yes"; private static final String ES_SYNC_VAL = "always"; private static final String ES_TPCONTROL_VAL = "false"; private static final String ES_IOPSCONTROL_VAL = "true"; /** * Private constructor s.t. its never instantiated. */ private ElastistorUtil() { } /** * This intializes a new jersey restclient for http call with elasticenter */ public static ElastiCenterClient getElastistorRestClient() { ElastiCenterClient restclient = null; try { String ip = getConfigurationDao().getValue("cloudbyte.management.ip"); String apikey = getConfigurationDao().getValue("cloudbyte.management.apikey"); if (ip == null) { throw new CloudRuntimeException("set the value of cloudbyte.management.ip in global settings"); } if (apikey == null) { throw new CloudRuntimeException("set the value of cloudbyte.management.apikey in global settings"); } restclient = new ElastiCenterClient(ip, apikey); } catch (InvalidCredentialsException e) { throw new CloudRuntimeException("InvalidCredentialsException:" + e.getMessage(), e); } catch (InvalidParameterException e) { throw new CloudRuntimeException("InvalidParameterException:" + e.getMessage(), e); } catch (SSLHandshakeException e) { throw new CloudRuntimeException("SSLHandshakeException:" + e.getMessage(), e); } catch (ServiceUnavailableException e) { throw new CloudRuntimeException("ServiceUnavailableException:" + e.getMessage(), e); } return restclient; } public static void setElastistorApiKey(String value) { s_esAPIKEYVAL = value; } public static void setElastistorManagementIp(String value) { s_esIPVAL = value; } public static void setElastistorPoolId(String value) { s_esPOOLIDVAL = value; } public static void setElastistorAccountId(String value) { s_esACCOUNTIDVAL = value; } public static void setElastistorGateway(String value) { s_esGATEWAYVAL = value; } public static void setElastistorInterface(String value) { s_esINTERFACEVAL = value; } public static void setElastistorSubnet(String value) { s_esSUBNETVAL = value; } /** * This creates a new Account in Elasticenter for the given Domain Name. * * @return */ public static String getElastistorAccountId(String domainName) throws Throwable { ListAccountResponse listAccountResponse = ListElastistorAccounts(); if (listAccountResponse.getAccounts().getCount() != 0) { int i; // check weather a account in elasticenter with given Domain name is // already present in the list of accounts for (i = 0; i < listAccountResponse.getAccounts().getCount(); i++) { if (domainName.equals(listAccountResponse.getAccounts().getAccount(i).getName())) { return listAccountResponse.getAccounts().getAccount(i).getUuid(); } } // if no account matches the give Domain Name , create one with the // Domain name CreateAccountResponse createAccountResponse = createElastistorAccount(domainName); return createAccountResponse.getAccount().getUuid(); } else { // if no account is present in the elasticenter create one CreateAccountResponse createAccountResponse = createElastistorAccount(domainName); return createAccountResponse.getAccount().getUuid(); } } /** * This creates a new tenant storage machine(TSM) for the given storagepool * ip in elastistor. * * @param domainName * TODO */ public static Tsm createElastistorTsm(String storagePoolName, String storageIp, Long capacityBytes, Long capacityIops, String domainName) throws Throwable { String totalthroughput = String.valueOf(capacityIops * 4); String totaliops = String.valueOf(capacityIops); String quotasize = convertCapacityBytes(capacityBytes); CreateTsmCmd createTsmCmd = new CreateTsmCmd(); if (null != ElastistorUtil.s_esACCOUNTIDVAL) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_ACCOUNTID, domainName); if (null != totalthroughput) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_TSM_THROUGHPUT, totalthroughput); if (null != ElastistorUtil.s_esPOOLIDVAL) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_POOLID, ElastistorUtil.s_esPOOLIDVAL); if (null != storagePoolName) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_NAME, storagePoolName); if (null != quotasize) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_QUOTA_SIZE, quotasize); if (null != storageIp) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_IPADDRESS, storageIp); if (null != ElastistorUtil.s_esSUBNETVAL) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_SUBNET, ElastistorUtil.s_esSUBNETVAL); if (null != ElastistorUtil.s_esGATEWAYVAL) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_GATEWAY, ElastistorUtil.s_esGATEWAYVAL); if (null != ElastistorUtil.s_esINTERFACEVAL) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_INTERFACE, ElastistorUtil.s_esINTERFACEVAL); if (null != ElastistorUtil.ES_NOOFCOPIES_VAL) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_NOOFCOPIES, ElastistorUtil.ES_NOOFCOPIES_VAL); if (null != ElastistorUtil.ES_BLOCKSIZE_VAL) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_RECORDSIZE, ElastistorUtil.ES_BLOCKSIZE_VAL); if (null != totaliops) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_TOTALIOPS, totaliops); if (null != ElastistorUtil.ES_LATENCY_VAL) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_LATENCY, ElastistorUtil.ES_LATENCY_VAL); if (null != ElastistorUtil.ES_BLOCKSIZE_VAL) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_BLOCKSIZE, ElastistorUtil.ES_BLOCKSIZE_VAL); if (null != ElastistorUtil.ES_GRACEALLOWED_VAL) createTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_GRACEALLOWED, ElastistorUtil.ES_GRACEALLOWED_VAL); CreateTsmCmdResponse createTsmCmdResponse; Tsm tsm = null; try { createTsmCmdResponse = (CreateTsmCmdResponse) getElastistorRestClient().executeCommand(createTsmCmd); if (createTsmCmdResponse.getJobid() == null) { throw new CloudRuntimeException("tsm creation failed , contact elatistor admin"); } else { tsm = queryAsyncTsmJobResult(createTsmCmdResponse.getJobid()); if (tsm == null) { throw new CloudRuntimeException("tsm queryAsync failed , contact elatistor admin"); } } return tsm; } catch (Exception e) { throw new CloudRuntimeException("tsm creation failed , contact elatistor admin" + e.toString()); } } /** * This creates the specified volume on the created tsm. */ public static FileSystem createElastistorVolume(String volumeName, String tsmid, Long capacityBytes, Long capacityIops, String protocoltype, String mountpoint) throws Throwable { String datasetid; String qosgroupid; String VolumeName = volumeName; String totaliops = String.valueOf(capacityIops); //String totalthroughput = String.valueOf(capacityIops * 4); String totalthroughput = "0"; String quotasize = convertCapacityBytes(capacityBytes); AddQosGroupCmd addQosGroupCmd = new AddQosGroupCmd(); ListTsmsResponse listTsmsResponse = listTsm(tsmid); tsmid = listTsmsResponse.getTsms().getTsm(0).getUuid(); datasetid = listTsmsResponse.getTsms().getTsm(0).getDatasetid(); if (null != VolumeName) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_NAME, "QOS_" + VolumeName); if (null != totaliops) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_IOPS, totaliops); if (null != ElastistorUtil.ES_LATENCY_VAL) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_LATENCY, ElastistorUtil.ES_LATENCY_VAL); if (null != totalthroughput) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_THROUGHPUT, totalthroughput); if (null != ElastistorUtil.ES_MEMLIMIT_VAL) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_MEMLIMIT, ElastistorUtil.ES_MEMLIMIT_VAL); if (null != ElastistorUtil.ES_NETWORKSPEED_VAL) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_NETWORKSPEED, ElastistorUtil.ES_NETWORKSPEED_VAL); if (null != tsmid) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_TSMID, tsmid); if (null != datasetid) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_DATASETID, datasetid); if (null != ElastistorUtil.ES_GRACEALLOWED_VAL) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_GRACEALLOWED, ElastistorUtil.ES_GRACEALLOWED_VAL); if (null != ElastistorUtil.ES_IOPSCONTROL_VAL) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_IOPSCONTROL, ElastistorUtil.ES_IOPSCONTROL_VAL); if (null != ElastistorUtil.ES_TPCONTROL_VAL) addQosGroupCmd.putCommandParameter(ElastistorUtil.REST_PARAM_TPCONTROL, ElastistorUtil.ES_TPCONTROL_VAL); AddQosGroupCmdResponse addQosGroupCmdResponse = (AddQosGroupCmdResponse) getElastistorRestClient() .executeCommand(addQosGroupCmd); if (addQosGroupCmdResponse.getQoSGroup().getUuid() == null) { throw new CloudRuntimeException("adding qos group failed , contact elatistor admin"); } else { CreateVolumeCmd createVolumeCmd = new CreateVolumeCmd(); qosgroupid = addQosGroupCmdResponse.getQoSGroup().getUuid(); // if (null != // ElastistorUtil.s_esACCOUNTIDVAL)createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_ACCOUNTID,ElastistorUtil.s_esACCOUNTIDVAL); if (null != qosgroupid) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_QOSGROUPID, qosgroupid); if (null != tsmid) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_TSMID, tsmid); // if (null != // ElastistorUtil.s_esPOOLIDVAL)createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_POOLID,ElastistorUtil.s_esPOOLIDVAL); if (null != VolumeName) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_NAME, VolumeName); if (null != quotasize) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_QUOTA_SIZE, quotasize); if (protocoltype.equalsIgnoreCase("nfs")) { if (null != ElastistorUtil.ES_BLOCKSIZE_VAL) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_BLOCKSIZE, ElastistorUtil.ES_BLOCKSIZE_VAL); if (null != ElastistorUtil.ES_BLOCKSIZE_VAL) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_RECORDSIZE, ElastistorUtil.ES_BLOCKSIZE_VAL); } else { if (null != ElastistorUtil.ES_BLOCKSIZE_VAL) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_BLOCKSIZE, "512B"); if (null != ElastistorUtil.ES_BLOCKSIZE_VAL) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_RECORDSIZE, "512B"); } if (null != ElastistorUtil.ES_DEDUPLICATION_VAL) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_DEDUPLICATION, ElastistorUtil.ES_DEDUPLICATION_VAL); if (null != ElastistorUtil.ES_SYNC_VAL) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_SYNC, ElastistorUtil.ES_SYNC_VAL); if (null != ElastistorUtil.ES_COMPRESSION_VAL) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_COMPRESSION, ElastistorUtil.ES_COMPRESSION_VAL); // if (null != // ElastistorUtil.ES_NOOFCOPIES_VAL)createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_NOOFCOPIES, // ElastistorUtil.ES_NOOFCOPIES_VAL); createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_MOUNTPOINT, mountpoint); // if (null != // ElastistorUtil.ES_CASESENSITIVITY_VAL)createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_CASESENSITIVITY, // ElastistorUtil.ES_CASESENSITIVITY_VAL); // if (null != // ElastistorUtil.ES_READONLY_VAL)createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_READONLY, // ElastistorUtil.ES_READONLY_VAL); if (null != datasetid) createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_DATASETID, datasetid); // if (null != // ElastistorUtil.ES_UNICODE_VAL)createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_UNICODE, // ElastistorUtil.ES_UNICODE_VAL); createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_PROTOCOLTYPE, protocoltype); // if (null != // ElastistorUtil.ES_AUTHNETWORK_VAL)createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_AUTHNETWORK, // ElastistorUtil.ES_AUTHNETWORK_VAL); // if (null != // ElastistorUtil.ES_MAPUSERSTOROOT_VAL)createVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_MAPUSERSTOROOT, // ElastistorUtil.ES_MAPUSERSTOROOT_VAL); CreateVolumeCmdResponse createVolumeCmdResponse; FileSystem volume = null; FileSystem fileSystem = null; try { createVolumeCmdResponse = (CreateVolumeCmdResponse) getElastistorRestClient() .executeCommand(createVolumeCmd); if (createVolumeCmdResponse.getJobid() == null) { throw new CloudRuntimeException("creating volume failed , contact elatistor admin"); } else { volume = queryAsyncVolumeJobResult(createVolumeCmdResponse.getJobid()); if (volume == null) { throw new CloudRuntimeException("tsm queryAsync failed , contact elatistor admin"); } else { if (protocoltype.equalsIgnoreCase("nfs")) { fileSystem = updateNfsService(volume.getUuid()); } else { fileSystem = updateIscsiService(volume.getUuid()); } } } return fileSystem; } catch (Exception e) { throw new CloudRuntimeException("creating volume failed , contact elatistor admin", e); } } } public static FileSystem updateNfsService(String volumeid) throws Throwable { FileSystem fileSystem = null; String datasetid = updateElastistorNfsVolume(volumeid); if (datasetid == null) { throw new CloudRuntimeException("Updating Nfs Volume Failed"); } else { fileSystem = listVolume(datasetid); if (fileSystem == null) { throw new CloudRuntimeException("Volume Creation failed : List Filesystem failed"); } } return fileSystem; } public static FileSystem updateIscsiService(String volumeid) throws Throwable { Volumeiscsioptions volumeiscsioptions = null; FileSystem fileSystem = null; String accountId; fileSystem = listVolume(volumeid); accountId = fileSystem.getAccountid(); volumeiscsioptions = updateElastistorIscsiVolume(volumeid, accountId); if (volumeiscsioptions == null) { throw new CloudRuntimeException("Updating Iscsi Volume Failed"); } else { fileSystem = listVolume(volumeiscsioptions.getVolumeid()); if (fileSystem == null) { throw new CloudRuntimeException("Volume Creation failed : List Filesystem failed"); } } return fileSystem; } public static String updateElastistorNfsVolume(String volumeid) throws Throwable { NfsServiceCmd nfsServiceCmd = new NfsServiceCmd(); nfsServiceCmd.putCommandParameter("datasetid", volumeid); nfsServiceCmd.putCommandParameter("authnetwork", "all"); nfsServiceCmd.putCommandParameter("managedstate", "true"); nfsServiceCmd.putCommandParameter("alldirs", "yes"); nfsServiceCmd.putCommandParameter("mapuserstoroot", "yes"); nfsServiceCmd.putCommandParameter("readonly", "no"); NfsServiceResponse nfsServiceResponse = (NfsServiceResponse) getElastistorRestClient() .executeCommand(nfsServiceCmd); if (nfsServiceResponse.getNfsService().getUuid() != null) { UpdateControllerCmd controllerCmd = new UpdateControllerCmd(); controllerCmd.putCommandParameter("nfsid", nfsServiceResponse.getNfsService().getUuid()); controllerCmd.putCommandParameter("type", "configurenfs"); controllerCmd.putCommandParameter("id", nfsServiceResponse.getNfsService().getControllerid()); UpdateControllerResponse controllerResponse = (UpdateControllerResponse) getElastistorRestClient() .executeCommand(controllerCmd); if (controllerResponse.getController().getUuid() != null) { s_logger.info("updated nfs service to ALL"); return nfsServiceResponse.getNfsService().getDatasetid(); } else { throw new CloudRuntimeException("Updating Nfs Volume Failed"); } } return null; } public static Volumeiscsioptions updateElastistorIscsiVolume(String volumeid, String accountid) throws Throwable { // now listing the iscsi volume service group to get iscsi id ListVolumeiSCSIServiceCmd listVolumeiSCSIServiceCmd = new ListVolumeiSCSIServiceCmd(); if (null != volumeid) listVolumeiSCSIServiceCmd.putCommandParameter(ElastistorUtil.REST_PARAM_STORAGEID, volumeid); ListVolumeiSCSIServiceResponse volumeiSCSIServiceResponse = (ListVolumeiSCSIServiceResponse) getElastistorRestClient() .executeCommand(listVolumeiSCSIServiceCmd); String iscsiId = volumeiSCSIServiceResponse.getIscsiVolume().getIscsiVolume(0).getUuid(); String AG_Id = volumeiSCSIServiceResponse.getIscsiVolume().getIscsiVolume(0).getAg_id(); // now listing the initiator group to get initiator id ListiSCSIInitiatorCmd initiatorCmd = new ListiSCSIInitiatorCmd(); if (null != volumeid) initiatorCmd.putCommandParameter(ElastistorUtil.REST_PARAM_ACCOUNTID, accountid); ListiSCSIInitiatorResponse initiatorResponse = (ListiSCSIInitiatorResponse) getElastistorRestClient() .executeCommand(initiatorCmd); String IG_Id; if (initiatorResponse.getIInitiator().getInterface(0).getInitiatorgroup().equalsIgnoreCase("ALL")) { IG_Id = initiatorResponse.getIInitiator().getInterface(0).getUuid(); } else { IG_Id = initiatorResponse.getIInitiator().getInterface(1).getUuid(); } if (iscsiId != null) { UpdateVolumeiSCSIServiceCmd updateVolumeiSCSIServiceCmd = new UpdateVolumeiSCSIServiceCmd(); if (null != volumeid) updateVolumeiSCSIServiceCmd.putCommandParameter(ElastistorUtil.REST_PARAM_ID, iscsiId); if (null != volumeid) updateVolumeiSCSIServiceCmd.putCommandParameter("status", "true"); if (null != volumeid) updateVolumeiSCSIServiceCmd.putCommandParameter("igid", IG_Id); if (null != volumeid) updateVolumeiSCSIServiceCmd.putCommandParameter("authgroupid", AG_Id); if (null != volumeid) updateVolumeiSCSIServiceCmd.putCommandParameter("initialdigest", "Auto"); if (null != volumeid) updateVolumeiSCSIServiceCmd.putCommandParameter("queuedepth", "32"); UpdateVolumeiSCSIServiceCmdResponse cmdResponse = (UpdateVolumeiSCSIServiceCmdResponse) getElastistorRestClient() .executeCommand(updateVolumeiSCSIServiceCmd); if (cmdResponse.getVolumeiscsioptions().getVolumeid() == null) { throw new CloudRuntimeException("Updating Iscsi Volume Failed"); } return cmdResponse.getVolumeiscsioptions(); } return null; } /** * This deletes both the volume and the tsm in elastistor. */ public static boolean deleteElastistorTsm(String tsmid, boolean managed) throws Throwable { if (!managed) { s_logger.info("elastistor pool is NOT a managed storage , hence deleting the volume then tsm"); String esvolumeid = null; ListTsmsResponse listTsmsResponse = listTsm(tsmid); if (listTsmsResponse.getTsmsCount() != 0) { if (listTsmsResponse.getTsms().getTsm(0).checkvolume()) { esvolumeid = listTsmsResponse.getTsms().getTsm(0).getVolumeProperties(0).getid(); DeleteVolumeResponse deleteVolumeResponse = deleteVolume(esvolumeid, null); if (deleteVolumeResponse != null) { String jobid = deleteVolumeResponse.getJobId(); int jobstatus = queryAsyncJobResult(jobid); if (jobstatus == 1) { s_logger.info("elastistor volume successfully deleted"); } else { s_logger.info("now farce deleting the volume"); while (jobstatus != 1) { DeleteVolumeResponse deleteVolumeResponse1 = deleteVolume(esvolumeid, "true"); if (deleteVolumeResponse1 != null) { String jobid1 = deleteVolumeResponse1.getJobId(); jobstatus = queryAsyncJobResult(jobid1); } } s_logger.info("elastistor volume successfully deleted"); } } } else { s_logger.info("no volume present in on the given tsm"); } } } s_logger.info("now trying to delete elastistor tsm"); if (tsmid != null) { DeleteTsmCmd deleteTsmCmd = new DeleteTsmCmd(); deleteTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_ID, tsmid); DeleteTsmResponse deleteTsmResponse = (DeleteTsmResponse) getElastistorRestClient() .executeCommand(deleteTsmCmd); if (deleteTsmResponse != null) { String jobstatus = deleteTsmResponse.getJobStatus(); if (jobstatus.equalsIgnoreCase("true")) { s_logger.info("deletion of elastistor tsm successful"); return true; } else { s_logger.info("failed to delete elastistor tsm"); return false; } } else { s_logger.info("elastistor tsm id not present"); } } s_logger.info("tsm id is null"); return false; /* * else { s_logger.error("no volume is present in the tsm"); } } else { * s_logger.error( * "List tsm failed, no tsm present in the eastistor for the given IP " * ); return false; } return false; */ } public static boolean deleteElastistorVolume(String esvolumeid) throws Throwable { FileSystem fileSystem = listVolume(esvolumeid); if (fileSystem != null) { DeleteVolumeResponse deleteVolumeResponse = deleteVolume(esvolumeid, null); if (deleteVolumeResponse != null) { String jobid = deleteVolumeResponse.getJobId(); int jobstatus = queryAsyncJobResult(jobid); if (jobstatus == 1) { s_logger.info("elastistor volume successfully deleted"); return true; } else { s_logger.info("now force deleting the volume"); while (jobstatus != 1) { DeleteVolumeResponse deleteVolumeResponse1 = deleteVolume(esvolumeid, "true"); if (deleteVolumeResponse1 != null) { String jobid1 = deleteVolumeResponse1.getJobId(); jobstatus = queryAsyncJobResult(jobid1); } } s_logger.info("elastistor volume successfully deleted"); return true; } } else { s_logger.info("the given volume is not present on elastistor, datasetrespone is NULL"); return false; } } else { s_logger.info("the given volume is not present on elastistor"); return false; } } /** * This give a json response containing the list of Interface's in * elastistor. */ public static ListInterfacesResponse ListElastistorInterfaces(String controllerid) throws Throwable { ListInterfacesCmd listInterfacesCmd = new ListInterfacesCmd(); listInterfacesCmd.putCommandParameter("controllerid", controllerid); ListInterfacesResponse interfacesResponse = (ListInterfacesResponse) getElastistorRestClient() .executeCommand(listInterfacesCmd); if (interfacesResponse != null && interfacesResponse.getInterfaces() != null) { return interfacesResponse; } else { throw new CloudRuntimeException("There are no elastistor interfaces."); } } /** * This give a json response containing the list of Accounts's in * elastistor. */ public static CreateAccountResponse createElastistorAccount(String domainName) throws Throwable { CreateAccountCmd createAccountCmd = new CreateAccountCmd(); createAccountCmd.putCommandParameter("name", domainName); CreateAccountResponse createAccountResponse = (CreateAccountResponse) getElastistorRestClient() .executeCommand(createAccountCmd); if (createAccountResponse != null) { return createAccountResponse; } else { throw new CloudRuntimeException("Creating Elastistor Account failed"); } } /** * This give a json response containing the list of Accounts's in * elastistor. */ public static ListAccountResponse ListElastistorAccounts() throws Throwable { ListAccountsCmd listAccountsCmd = new ListAccountsCmd(); ListAccountResponse accountResponse = (ListAccountResponse) getElastistorRestClient() .executeCommand(listAccountsCmd); if (accountResponse != null) { return accountResponse; } else { throw new CloudRuntimeException("List Elastistor Account failed"); } } /** * This give a json response containing the list of Pool's in elastistor. */ public static ListPoolsResponse ListElastistorPools() throws Throwable { ListPoolsCmd listPoolsCmd = new ListPoolsCmd(); ListPoolsResponse listPoolsResponse = (ListPoolsResponse) getElastistorRestClient() .executeCommand(listPoolsCmd); if (listPoolsResponse != null) { return listPoolsResponse; } else { throw new CloudRuntimeException("List Elastistor pool failed"); } } /** * This give a json response containing the list of tsm's in elastistor. */ private static ListTsmsResponse listTsm(String uuid) throws Throwable { ListTsmCmd listTsmCmd = new ListTsmCmd(); listTsmCmd.putCommandParameter(ElastistorUtil.REST_PARAM_ID, uuid); ListTsmsResponse listTsmsResponse = (ListTsmsResponse) getElastistorRestClient().executeCommand(listTsmCmd); return listTsmsResponse; } /** * This give a json response containing the list of Volume in elastistor. */ public static FileSystem listVolume(String uuid) throws Throwable { ListFileSystemCmd listFileSystemCmd = new ListFileSystemCmd(); listFileSystemCmd.putCommandParameter(ElastistorUtil.REST_PARAM_ID, uuid); ListFileSystemResponse listFileSystemResponse = (ListFileSystemResponse) getElastistorRestClient() .executeCommand(listFileSystemCmd); return listFileSystemResponse.getFilesystems().getFileSystem(0); } private static DeleteVolumeResponse deleteVolume(String esvolumeid, String forcedelete) throws Throwable { DeleteVolumeCmd deleteVolumeCmd = new DeleteVolumeCmd(); deleteVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_ID, esvolumeid); deleteVolumeCmd.putCommandParameter(ElastistorUtil.REST_PARAM_FORECEDELETE, forcedelete); DeleteVolumeResponse deleteVolumeResponse = (DeleteVolumeResponse) getElastistorRestClient() .executeCommand(deleteVolumeCmd); return deleteVolumeResponse; } private static int queryAsyncJobResult(String jobid) throws Throwable { QueryAsyncJobResultCmd asyncJobResultCmd = new QueryAsyncJobResultCmd(); ElastiCenterClient restclient = getElastistorRestClient(); asyncJobResultCmd.putCommandParameter(ElastistorUtil.REST_PARAM_JOBID, jobid); QueryAsyncJobResultResponse asyncJobResultResponse = (QueryAsyncJobResultResponse) restclient .executeCommand(asyncJobResultCmd); if (asyncJobResultResponse != null) { int jobstatus = asyncJobResultResponse.getAsync().getJobStatus(); while (jobstatus == 0) { QueryAsyncJobResultResponse jobResultResponse = (QueryAsyncJobResultResponse) restclient .executeCommand(asyncJobResultCmd); jobstatus = jobResultResponse.getAsync().getJobStatus(); } return jobstatus; } return 0; } private static Tsm queryAsyncTsmJobResult(String jobid) throws Throwable { QueryAsyncJobResultCmd asyncJobResultCmd = new QueryAsyncJobResultCmd(); ElastiCenterClient restclient = getElastistorRestClient(); asyncJobResultCmd.putCommandParameter(ElastistorUtil.REST_PARAM_JOBID, jobid); QueryAsyncJobResultResponse asyncJobResultResponse = (QueryAsyncJobResultResponse) restclient .executeCommand(asyncJobResultCmd); if (asyncJobResultResponse != null) { int jobstatus = asyncJobResultResponse.getAsync().getJobStatus(); Tsm tsm = null; while (jobstatus == 0) { asyncJobResultResponse = (QueryAsyncJobResultResponse) restclient.executeCommand(asyncJobResultCmd); jobstatus = asyncJobResultResponse.getAsync().getJobStatus(); } if (jobstatus == 1) { tsm = asyncJobResultResponse.getAsync().getJobResult().getTsm(); return tsm; } } return null; } private static FileSystem queryAsyncVolumeJobResult(String jobid) throws Throwable { QueryAsyncJobResultCmd asyncJobResultCmd = new QueryAsyncJobResultCmd(); ElastiCenterClient restclient = getElastistorRestClient(); asyncJobResultCmd.putCommandParameter(ElastistorUtil.REST_PARAM_JOBID, jobid); QueryAsyncJobResultResponse asyncJobResultResponse = (QueryAsyncJobResultResponse) restclient .executeCommand(asyncJobResultCmd); if (asyncJobResultResponse != null) { int jobstatus = asyncJobResultResponse.getAsync().getJobStatus(); FileSystem volume = null; while (jobstatus == 0) { asyncJobResultResponse = (QueryAsyncJobResultResponse) restclient.executeCommand(asyncJobResultCmd); jobstatus = asyncJobResultResponse.getAsync().getJobStatus(); } if (jobstatus == 1) { volume = asyncJobResultResponse.getAsync().getJobResult().getVolume(); return volume; } } return null; } /** * this method converts the long capacitybytes to string format, which is * feasible for elastistor rest api 214748364800 = 200G. */ private static String convertCapacityBytes(Long capacityBytes) { if ((1099511627776L) > capacityBytes && (capacityBytes > (1073741824))) { return (String.valueOf(capacityBytes / (1024 * 1024 * 1024)) + "G"); } else { int temp1 = (int) (capacityBytes / (1024 * 1024 * 1024)); int temp2 = temp1 / 1024; return (String.valueOf(temp2) + "T"); } } static interface ElastiCenterCommand { /* * Returns the command string to be sent to the ElastiCenter */ public String getCommandName(); /* * Utility method to allow the client to validate the input parameters * before sending to the ElastiCenter. * * This command will be executed by the ElastiCenterClient only this * method returns true. */ public boolean validate(); /* * Returns the query parameters that have to be passed to execute the * command. * * Returns null if there are query parameters associated with the * command */ public MultivaluedMap<String, String> getCommandParameters(); /* * Adds new key-value pair to the query paramters lists. */ public void putCommandParameter(String key, String value); /* * Return an instance of the Response Object Type. * * Return null if no response is expected. */ public Object getResponseObject(); } private static class BaseCommand implements ElastiCenterCommand { private String commandName = null; private MultivaluedMap<String, String> commandParameters = null; private Object responseObject = null; /* * Enforce the Commands to be initialized with command name and optional * response object */ protected BaseCommand(String cmdName, Object responseObj) { commandName = cmdName; responseObject = responseObj; } @Override public String getCommandName() { return commandName; } @Override public boolean validate() { // TODO This method can be extended to do some generic // validations. return true; } @Override public MultivaluedMap<String, String> getCommandParameters() { return commandParameters; } @Override public void putCommandParameter(String key, String value) { if (null == commandParameters) { commandParameters = new MultivaluedMapImpl(); } commandParameters.add(key, value); } @Override public Object getResponseObject() { return responseObject; } } /** * this is a rest client which is used to call the http rest calls to * elastistor * * @author punith * */ private static final class ElastiCenterClient { public static boolean debug = false; private boolean initialized = false; private String apiKey = null; private String elastiCenterAddress = null; private String responseType = "json"; private boolean ignoreSSLCertificate = false; private String restprotocol = "https://"; private String restpath = "/client/api"; private String restdefaultcommand = "listCapabilities"; private String queryparamcommand = "command"; private String queryparamapikey = "apikey"; private String queryparamresponse = "response"; public ElastiCenterClient(String address, String key) throws InvalidCredentialsException, InvalidParameterException, SSLHandshakeException, ServiceUnavailableException { elastiCenterAddress = address; apiKey = key; initialize(); } public void initialize() throws InvalidParameterException, SSLHandshakeException, InvalidCredentialsException, ServiceUnavailableException { if (apiKey == null || apiKey.trim().isEmpty()) { throw new InvalidParameterException("Unable to initialize. Please specify a valid API Key."); } if (elastiCenterAddress == null || elastiCenterAddress.trim().isEmpty()) { // TODO : Validate the format, like valid IP address or // hostname. throw new InvalidParameterException( "Unable to initialize. Please specify a valid ElastiCenter IP Address or Hostname."); } if (ignoreSSLCertificate) { // Create a trust manager that does not validate certificate // chains TrustManager[] trustAllCerts = new TrustManager[] { new X509TrustManager() { @Override public X509Certificate[] getAcceptedIssuers() { return null; } @Override public void checkClientTrusted(X509Certificate[] certs, String authType) { } @Override public void checkServerTrusted(X509Certificate[] certs, String authType) { } } }; HostnameVerifier hv = new HostnameVerifier() { @Override public boolean verify(String urlHostName, SSLSession session) { return true; } }; // Install the all-trusting trust manager try { SSLContext sc = SSLUtils.getSSLContext(); sc.init(null, trustAllCerts, new SecureRandom()); HttpsURLConnection.setDefaultSSLSocketFactory(new SecureSSLSocketFactory(sc)); HttpsURLConnection.setDefaultHostnameVerifier(hv); } catch (Exception e) { ; } } ListCapabilitiesResponse listCapabilitiesResponse = null; try { initialized = true; listCapabilitiesResponse = (ListCapabilitiesResponse) executeCommand(restdefaultcommand, null, new ListCapabilitiesResponse()); } catch (Throwable t) { initialized = false; if (t instanceof InvalidCredentialsException) { throw (InvalidCredentialsException) t; } else if (t instanceof ServiceUnavailableException) { throw (ServiceUnavailableException) t; } else if (t.getCause() instanceof SSLHandshakeException) { throw new SSLHandshakeException( "Unable to initialize. An untrusted SSL Certificate was received from " + elastiCenterAddress + ". Please verify your truststore or configure ElastiCenterClient to skip the SSL Validation. "); } else if (t.getCause() instanceof ConnectException) { throw new ServiceUnavailableException("Unable to initialize. Failed to connect to " + elastiCenterAddress + ". Please verify the IP Address, Network Connectivity and ensure that Services are running on the ElastiCenter Server. "); } throw new ServiceUnavailableException( "Unable to initialize. Please contact your ElastiCenter Administrator. Exception " + t.getMessage()); } if (null == listCapabilitiesResponse || null == listCapabilitiesResponse.getCapabilities() || null == listCapabilitiesResponse.getCapabilities().getVersion()) { initialized = false; throw new ServiceUnavailableException("Unable to execute command on the server"); } } public Object executeCommand(ElastiCenterCommand cmd) throws Throwable { return executeCommand(cmd.getCommandName(), cmd.getCommandParameters(), cmd.getResponseObject()); } public Object executeCommand(String command, MultivaluedMap<String, String> params, Object responeObj) throws Throwable { if (!initialized) { throw new IllegalStateException("Error : ElastiCenterClient is not initialized."); } if (command == null || command.trim().isEmpty()) { throw new InvalidParameterException("No command to execute."); } try { ClientConfig config = new DefaultClientConfig(); Client client = Client.create(config); WebResource webResource = client .resource(UriBuilder.fromUri(restprotocol + elastiCenterAddress + restpath).build()); MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl(); queryParams.add(queryparamapikey, apiKey); queryParams.add(queryparamresponse, responseType); queryParams.add(queryparamcommand, command); if (null != params) { for (String key : params.keySet()) { queryParams.add(key, params.getFirst(key)); } } if (debug) { System.out.println("Command Sent " + command + " : " + queryParams); } ClientResponse response = webResource.queryParams(queryParams).accept(MediaType.APPLICATION_JSON) .get(ClientResponse.class); if (response.getStatus() >= 300) { if (debug) System.out.println("ElastiCenter returned error code : " + response.getStatus()); if (401 == response.getStatus()) { throw new InvalidCredentialsException("Please specify a valid API Key."); } else if (431 == response.getStatus()) { throw new InvalidParameterException(response.getHeaders().getFirst("X-Description")); } else if (432 == response.getStatus()) { throw new InvalidParameterException(command + " does not exist on the ElastiCenter server. Please specify a valid command or contact your ElastiCenter Administrator."); } else { throw new ServiceUnavailableException( "Internal Error. Please contact your ElastiCenter Administrator."); } } else if (null != responeObj) { String jsonResponse = response.getEntity(String.class); if (debug) { System.out.println("Command Response : " + jsonResponse); } Gson gson = new Gson(); return gson.fromJson(jsonResponse, responeObj.getClass()); } else { return "Success"; } } catch (Throwable t) { throw t; } } } /** * these are the list of Elastistor rest commands being called from the * plugin. */ private static final class CreateTsmCmd extends BaseCommand { public CreateTsmCmd() { super("createTsm", new CreateTsmCmdResponse()); } } private static final class AddQosGroupCmd extends BaseCommand { public AddQosGroupCmd() { super("addQosGroup", new AddQosGroupCmdResponse()); } } private static final class CreateVolumeCmd extends BaseCommand { public CreateVolumeCmd() { super("createVolume", new CreateVolumeCmdResponse()); } } private static final class ListVolumeiSCSIServiceCmd extends BaseCommand { public ListVolumeiSCSIServiceCmd() { super("listVolumeiSCSIService", new ListVolumeiSCSIServiceResponse()); } } private static final class ListiSCSIInitiatorCmd extends BaseCommand { public ListiSCSIInitiatorCmd() { super("listiSCSIInitiator", new ListiSCSIInitiatorResponse()); } } private static final class NfsServiceCmd extends BaseCommand { public NfsServiceCmd() { super("nfsService", new NfsServiceResponse()); } } private static final class UpdateControllerCmd extends BaseCommand { public UpdateControllerCmd() { super("updateController", new UpdateControllerResponse()); } } private static final class UpdateVolumeiSCSIServiceCmd extends BaseCommand { public UpdateVolumeiSCSIServiceCmd() { super("updateVolumeiSCSIService", new UpdateVolumeiSCSIServiceCmdResponse()); } } private static final class DeleteTsmCmd extends BaseCommand { public DeleteTsmCmd() { super("deleteTsm", new DeleteTsmResponse()); } } private static final class DeleteVolumeCmd extends BaseCommand { public DeleteVolumeCmd() { super("deleteFileSystem", new DeleteVolumeResponse()); } } private static final class QueryAsyncJobResultCmd extends BaseCommand { public QueryAsyncJobResultCmd() { super("queryAsyncJobResult", new QueryAsyncJobResultResponse()); } } private static final class ListTsmCmd extends BaseCommand { public ListTsmCmd() { super("listTsm", new ListTsmsResponse()); } } private static final class ListFileSystemCmd extends BaseCommand { public ListFileSystemCmd() { super("listFileSystem", new ListFileSystemResponse()); } } private static final class ListAccountsCmd extends BaseCommand { public ListAccountsCmd() { super("listAccount", new ListAccountResponse()); } } private static final class CreateAccountCmd extends BaseCommand { public CreateAccountCmd() { super("createAccount", new CreateAccountResponse()); } } private static final class ListInterfacesCmd extends BaseCommand { public ListInterfacesCmd() { super("listSharedNICs", new ListInterfacesResponse()); } } private static final class ListPoolsCmd extends BaseCommand { public ListPoolsCmd() { super("listHAPool", new ListPoolsResponse()); } } /** * these are the list of Elastistor rest json response classes for parsing * the json response sent by elastistor. * */ public static final class CreateTsmCmdResponse { @SerializedName("addTsmResponse") private JobId jobId; public String getJobid() { return jobId.getJobid(); } public String getJobStatus() { return jobId.getJobStatus(); } @SerializedName("createTsmResponse") private TsmWrapper tsmWrapper; public Tsm getTsm() { return tsmWrapper.getTsm(); } } public static final class Tsm { @SerializedName("id") private String uuid; @SerializedName("name") private String name; @SerializedName("datasetid") private String datasetid; @SerializedName("ipaddress") private String ipaddress; @SerializedName("volumes") private VolumeProperties[] volumeProperties; public String getUuid() { return uuid; } public String getName() { return name; } public String getIpaddress() { return ipaddress; } public String getDatasetid() { return datasetid; } public boolean checkvolume() { if (volumeProperties != null) { return true; } else { return false; } } public VolumeProperties getVolumeProperties(int i) { return volumeProperties[i]; } } public static final class VolumeProperties { @SerializedName("id") private String id; @SerializedName("groupid") private String groupid; @SerializedName("iops") private String iops; @SerializedName("name") private String name; public String getid() { return id; } public String getQosgroupid() { return groupid; } public String getName() { return name; } public String getIops() { return iops; } } public static final class TsmWrapper { @SerializedName("tsm") private Tsm tsm; public Tsm getTsm() { return tsm; } } public static final class AddQosGroupCmdResponse { @SerializedName("addqosgroupresponse") private QoSGroupWrapper qosGroupWrapper; public QoSGroup getQoSGroup() { return qosGroupWrapper.getQosGroup(); } } public static final class QoSGroupWrapper { @SerializedName("qosgroup") private QoSGroup qoSGroup; public QoSGroup getQosGroup() { return qoSGroup; } } public static final class QoSGroup { @SerializedName("id") private String uuid; @SerializedName("name") private String name; @SerializedName("qosgroupproperties") private HashMap<String, String> qosGroupProperties; public String getName() { return name; } public String getUuid() { return uuid; } public String getIops() { return qosGroupProperties.get("iops"); } public String getThroughput() { return qosGroupProperties.get("throughput"); } public String getLatency() { return qosGroupProperties.get("latency"); } } public static final class UpdateVolumeiSCSIServiceCmdResponse { @SerializedName("updatingvolumeiscsidetails") private VolumeiSCSIServiceWrapper volumeiSCSIServiceWrapper; public Volumeiscsioptions getVolumeiscsioptions() { return volumeiSCSIServiceWrapper.getVolumeiscsioptions(); } } public static final class VolumeiSCSIServiceWrapper { @SerializedName("viscsioptions") private Volumeiscsioptions viscsioptions; public Volumeiscsioptions getVolumeiscsioptions() { return viscsioptions; } } public static final class Volumeiscsioptions { @SerializedName("id") private String uuid; @SerializedName("volume_id") private String volumeid; @SerializedName("iqnname") private String iqnname; public String getUuid() { return uuid; } public String getVolumeid() { return volumeid; } public String getIqn() { return iqnname; } } public static final class NfsServiceResponse { @SerializedName("nfsserviceprotocolresponse") private NfsServiceWrapper nfsServiceWrapper; public NfsService getNfsService() { return nfsServiceWrapper.getNfsservice(); } } public static final class NfsServiceWrapper { @SerializedName("nfs") private NfsService nfsService; public NfsService getNfsservice() { return nfsService; } } public static final class NfsService { @SerializedName("id") private String uuid; @SerializedName("STORAGEID") private String datasetid; @SerializedName("controllerid") private String controllerid; @SerializedName("authnetwork") private String authnetwork; public String getUuid() { return uuid; } public String getDatasetid() { return datasetid; } public String getControllerid() { return controllerid; } public String getAuthnetwork() { return authnetwork; } } public static final class UpdateControllerResponse { @SerializedName("updateControllerResponse") private UpdateControllerWrapper controllerWrapper; public Controller getController() { return controllerWrapper.getController(); } } public static final class UpdateControllerWrapper { @SerializedName("controller") private Controller controller; public Controller getController() { return controller; } } public static final class Controller { @SerializedName("id") private String uuid; public String getUuid() { return uuid; } } public static final class CreateVolumeCmdResponse { @SerializedName("createvolumeresponse") private JobId jobId; public String getJobid() { return jobId.getJobid(); } @SerializedName("adddatasetresponse") private FileSystemWrapper fileSystemWrapper; public FileSystem getFileSystem() { return fileSystemWrapper.getFileSystem(); } } public static final class FileSystemWrapper { @SerializedName("filesystem") private FileSystem fileSystem; public FileSystem getFileSystem() { return fileSystem; } } public static final class FileSystem { @SerializedName("id") private String uuid; @SerializedName("name") private String name; @SerializedName("quota") private String quota; @SerializedName("accountid") private String accountid; @SerializedName("iqnname") private String iqnname; @SerializedName("nfsenabled") private String nfsenabled; @SerializedName("iscsienabled") private String iscsienabled; @SerializedName("path") private String path; @SerializedName("groupid") private String groupid; @SerializedName("compression") private String compression; @SerializedName("sync") private String sync; @SerializedName("deduplication") private String deduplication; @SerializedName("graceallowed") private String graceallowed; public String getCompression() { return compression; } public String getSync() { return sync; } public String getDeduplication() { return deduplication; } public String getGraceallowed() { return graceallowed; } public String getUuid() { return uuid; } public String getQosGroupid() { return groupid; } public String getName() { return name; } public String getNfsenabled() { return nfsenabled; } public String getIscsienabled() { return iscsienabled; } public String getPath() { return path; } public String getIqn() { return iqnname; } public String getQuota() { return quota; } public String getAccountid() { return accountid; } } public static final class DeleteTsmResponse { @SerializedName("deleteTsmResponse") private JobId jobId; public String getJobStatus() { return jobId.getJobStatus(); } } public static final class JobId { @SerializedName("jobid") private String jobid; @SerializedName("success") private String jobStatus; @SerializedName("jobresult") private JobResult jobresult; @SerializedName("tsm") private Tsm tsm; @SerializedName("storage") private FileSystem volume; public Tsm getTsm() { return tsm; } public FileSystem getVolume() { return volume; } public JobResult getJobResult() { return jobresult; } public String getJobid() { return jobid; } public String getJobStatus() { return jobStatus; } } public static final class JobResult { @SerializedName("tsm") private Tsm tsm; @SerializedName("storage") private FileSystem volume; public Tsm getTsm() { return tsm; } public FileSystem getVolume() { return volume; } } public static final class DeleteVolumeResponse { @SerializedName("deleteFileSystemResponse") private JobId jobId; public String getJobId() { return jobId.getJobid(); } } public static final class ListCapabilitiesResponse { @SerializedName("listcapabilitiesresponse") private Capabilities capabilities; public Capabilities getCapabilities() { return capabilities; } } public static final class ListFileSystemResponse { @SerializedName("listFilesystemResponse") private Filesystems filesystems; public int getFilesystemCount() { return filesystems.getCount(); } public Filesystems getFilesystems() { return filesystems; } } public static final class Filesystems { @SerializedName("count") private int count; @SerializedName("filesystem") private FileSystem[] fileSystems; public int getCount() { return count; } public FileSystem getFileSystem(int i) { return fileSystems[i]; } } public static final class ListPoolsResponse { @SerializedName("listHAPoolResponse") private Pools pools; public Pools getPools() { return pools; } } public static final class Pools { @SerializedName("hapool") private Pool[] pool; @SerializedName("count") private int count; public Pool getPool(int i) { return pool[i]; } public int getCount() { return count; } } public static final class Pool { @SerializedName("id") private String uuid; @SerializedName("name") private String name; @SerializedName("currentAvailableSpace") private String currentAvailableSpace; @SerializedName("availIOPS") private String availIOPS; @SerializedName("status") private String state; @SerializedName("controllerid") private String controllerid; @SerializedName("gateway") private String gateway; public String getControllerid() { return controllerid; } public String getUuid() { return uuid; } public String getName() { return name; } public String getAvailableSpace() { return currentAvailableSpace; } public String getAvailIOPS() { return availIOPS; } public String getState() { return state; } public String getGateway() { return gateway; } } public static final class ListInterfacesResponse { @SerializedName("listSharedNICsResponse") private Interfaces interfaces; public Interfaces getInterfaces() { return interfaces; } } public static final class Interfaces { @SerializedName("nic") private Interface[] interfaces; @SerializedName("count") private int count; public Interface getInterface(int i) { return interfaces[i]; } public int getCount() { return count; } } public static final class Interface { @SerializedName("id") private String uuid; @SerializedName("name") private String name; @SerializedName("status") private String status; public String getUuid() { return uuid; } public String getName() { return name; } public String getStatus() { return status; } } public static final class ListiSCSIInitiatorResponse { @SerializedName("listInitiatorsResponse") private Initiators initiators; public Initiators getIInitiator() { return initiators; } } public static final class Initiators { @SerializedName("initiator") private Initiator[] initiators; @SerializedName("count") private int count; public Initiator getInterface(int i) { return initiators[i]; } public int getCount() { return count; } } public static final class Initiator { @SerializedName("id") private String uuid; @SerializedName("name") private String name; @SerializedName("initiatorgroup") private String initiatorgroup; public String getUuid() { return uuid; } public String getName() { return name; } public String getInitiatorgroup() { return initiatorgroup; } } public static final class ListAccountResponse { @SerializedName("listAccountResponse") private Accounts accounts; public Accounts getAccounts() { return accounts; } } public static final class Accounts { @SerializedName("account") private Account[] Accounts; @SerializedName("count") private int count; public Account getAccount(int i) { return Accounts[i]; } public int getCount() { return count; } } public static final class CreateAccountResponse { @SerializedName("createaccountresponse") private Accounts2 accounts; public Account getAccount() { return accounts.getAccount(); } } public static final class Accounts2 { @SerializedName("account2") private Account Account; @SerializedName("count") private int count; public Account getAccount() { return Account; } public int getCount() { return count; } } public static final class Account { @SerializedName("id") private String uuid; @SerializedName("name") private String name; public String getUuid() { return uuid; } public String getName() { return name; } } public static final class ListTsmsResponse { @SerializedName("listTsmResponse") private Tsms tsms; public int getTsmsCount() { return tsms.getCount(); } public Tsms getTsms() { return tsms; } } public static final class Tsms { @SerializedName("count") private int count; @SerializedName("listTsm") private Tsm[] tsms; public int getCount() { return count; } public Tsm getTsm(int i) { return tsms[i]; } } public static final class ListVolumeiSCSIServiceResponse { @SerializedName("listVolumeiSCSIServiceResponse") private IscsiVolumeService iscsiVolumes; public int getVolumeCount() { return iscsiVolumes.getCount(); } public IscsiVolumeService getIscsiVolume() { return iscsiVolumes; } } public static final class IscsiVolumeService { @SerializedName("count") private int count; @SerializedName("iSCSIService") private IscsiVolume[] iscsiVolumes; public int getCount() { return count; } public IscsiVolume getIscsiVolume(int i) { return iscsiVolumes[i]; } } public static final class IscsiVolume { @SerializedName("id") private String uuid; @SerializedName("ag_id") private String agid; @SerializedName("ig_id") private String igid; public String getAg_id() { return agid; } public String getUuid() { return uuid; } public String getIg_id() { return igid; } } public static final class QueryAsyncJobResultResponse { @SerializedName("queryasyncjobresultresponse") private Async async; public Async getAsync() { return async; } } public static final class Async { @SerializedName("jobstatus") private int jobstatus; @SerializedName("jobresult") private JobId jobresult; @SerializedName("cmd") private String cmd; public int getJobStatus() { return jobstatus; } public JobId getJobResult() { return jobresult; } public String getCmd() { return cmd; } } public static final class Capabilities { @SerializedName("capability") private HashMap<String, String> capabilites; public String getVersion() { return capabilites.get("cloudByteVersion"); } } /* * * change Volume IOPS */ public static Answer updateElastistorVolumeQosGroup(String volumeId, Long newIOPS, String graceAllowed) throws Throwable { FileSystem fileSystem = listVolume(volumeId); String qosid = fileSystem.getQosGroupid(); if (qosid != null) { UpdateQosGroupCmdResponse qosGroupCmdResponse = updateQosGroupVolume(newIOPS.toString(), qosid, graceAllowed); if (qosGroupCmdResponse.getQoSGroup(0).uuid != null) { return new Answer(null, true, null); } else { return new Answer(null, false, "Update Qos Group Failed"); } } else { return new Answer(null, false, "Qos Group id is NULL"); } } private static UpdateQosGroupCmdResponse updateQosGroupVolume(String iops, String qosgroupid, String graceAllowed) throws Throwable { UpdateQosGroupCmd updateQosGroupCmd = new UpdateQosGroupCmd(); updateQosGroupCmd.putCommandParameter("id", qosgroupid); updateQosGroupCmd.putCommandParameter("iops", iops); updateQosGroupCmd.putCommandParameter("graceallowed", graceAllowed); UpdateQosGroupCmdResponse updateQosGroupCmdResponse = (UpdateQosGroupCmdResponse) getElastistorRestClient() .executeCommand(updateQosGroupCmd); return updateQosGroupCmdResponse; } private static final class UpdateQosGroupCmd extends BaseCommand { public UpdateQosGroupCmd() { super("updateQosGroup", new UpdateQosGroupCmdResponse()); } } public static final class UpdateQosGroupCmdResponse { @SerializedName("updateqosresponse") private QoSGroupWrapperChangeVolumeIops qosGroupWrapper; public QoSGroup getQoSGroup(int i) { return qosGroupWrapper.getQosGroup(i); } } public static final class QoSGroupWrapperChangeVolumeIops { @SerializedName("qosgroup") private QoSGroup qoSGroup[]; public QoSGroup getQosGroup(int i) { return qoSGroup[i]; } } /* * resize volume */ public static Boolean updateElastistorVolumeSize(String volumeId, Long newSize) throws Throwable { Boolean status = false; String quotasize = (String.valueOf(newSize / (1024 * 1024 * 1024)) + "G"); UpdateFileSystemCmdResponse fileSystemCmdResponse = updateFileSystem(quotasize, volumeId, null, null, null); if (fileSystemCmdResponse.getFileSystem(0).uuid != null) { status = true; return status; } return status; } public static UpdateFileSystemCmdResponse updateFileSystem(String quotasize, String esvolumeid, String dedeplication, String compression, String sync) throws Throwable { UpdateFileSystemCmd fileSystemCmd = new UpdateFileSystemCmd(); fileSystemCmd.putCommandParameter("id", esvolumeid); if (null != quotasize) fileSystemCmd.putCommandParameter("quotasize", quotasize); if (null != dedeplication) fileSystemCmd.putCommandParameter("deduplication", dedeplication); if (null != compression) fileSystemCmd.putCommandParameter("compression", compression); if (null != sync) fileSystemCmd.putCommandParameter("sync", sync); UpdateFileSystemCmdResponse fileSystemCmdResponse = (UpdateFileSystemCmdResponse) getElastistorRestClient() .executeCommand(fileSystemCmd); return fileSystemCmdResponse; } private static final class UpdateFileSystemCmd extends BaseCommand { public UpdateFileSystemCmd() { super("updateFileSystem", new UpdateFileSystemCmdResponse()); } } private static final class UpdateFileSystemCmdResponse { @SerializedName("updatefilesystemresponse") private UpdateFileSystemWrapper fileSystemWrapper; public FileSystem getFileSystem(int i) { return fileSystemWrapper.getFileSystem(i); } } public class UpdateFileSystemWrapper { @SerializedName("filesystem") private FileSystem fileSystem[]; public FileSystem getFileSystem(int i) { return fileSystem[i]; } } /* * create snapshot */ public static Answer createElastistorVolumeSnapshot(String volumeId, String snapshotName) throws Throwable { CreateStorageSnapshotCmd snapshotCmd = new CreateStorageSnapshotCmd(); snapshotCmd.putCommandParameter("id", volumeId); snapshotCmd.putCommandParameter("name", snapshotName); CreateStorageSnapshotCmdResponse snapshotCmdResponse = (CreateStorageSnapshotCmdResponse) getElastistorRestClient() .executeCommand(snapshotCmd); if (snapshotCmdResponse.getStorageSnapshot().getId() != null) { return new Answer(null, true, snapshotCmdResponse.getStorageSnapshot().getId()); } else { return new Answer(null, false, "snapshot failed"); } } private static final class CreateStorageSnapshotCmd extends BaseCommand { public CreateStorageSnapshotCmd() { super("createStorageSnapshot", new CreateStorageSnapshotCmdResponse()); } } private static final class CreateStorageSnapshotCmdResponse { @SerializedName("createStorageSnapshotResponse") private StorageSnapshotWrapper StorageSnapshot; public StorageSnapshot getStorageSnapshot() { return StorageSnapshot.getStorageSnapshot(); } } public static final class StorageSnapshotWrapper { @SerializedName("StorageSnapshot") private StorageSnapshot snapshot; public StorageSnapshot getStorageSnapshot() { return snapshot; } } public static final class StorageSnapshot { @SerializedName("id") private String uuid; @SerializedName("name") private String name; public String getId() { return uuid; } public String getName() { return name; } } // update the TSM storage public static UpdateTsmStorageCmdResponse updateElastistorTsmStorage(String capacityBytes, String uuid) throws Throwable { Long size = (Long.parseLong(capacityBytes) / (1024 * 1024 * 1024)); String quotasize = null; if (size > 1024) { quotasize = (String.valueOf(Long.parseLong(capacityBytes) / (1024)) + "T"); } else { quotasize = String.valueOf(quotasize) + "G"; } s_logger.info("elastistor tsm storage is updating to " + quotasize); UpdateTsmStorageCmd updateTsmStorageCmd = new UpdateTsmStorageCmd(); updateTsmStorageCmd.putCommandParameter("id", uuid); updateTsmStorageCmd.putCommandParameter("quotasize", quotasize); UpdateTsmStorageCmdResponse updateTsmStorageCmdResponse = (UpdateTsmStorageCmdResponse) getElastistorRestClient() .executeCommand(updateTsmStorageCmd); return updateTsmStorageCmdResponse; } private static final class UpdateTsmStorageCmd extends BaseCommand { public UpdateTsmStorageCmd() { super("updateStorage", new UpdateTsmStorageCmdResponse()); } } public static final class UpdateTsmStorageCmdResponse { @SerializedName("updatedatasetresponse") private StorageWrapper storageWrapper; public Storage getStorage() { return storageWrapper.getStorage(); } } public static final class StorageWrapper { @SerializedName("storage") private Storage storage; public Storage getStorage() { return storage; } } public static final class Storage { @SerializedName("id") private String uuid; @SerializedName("name") private String name; @SerializedName("quota") private String quota; public String getId() { return uuid; } public String getName() { return name; } public String getsize() { return quota; } } // update the TSM IOPS public static UpdateTsmCmdResponse updateElastistorTsmIOPS(String capacityIOPs, String uuid) throws Throwable { s_logger.info("elastistor tsm IOPS is updating to " + capacityIOPs); UpdateTsmCmd updateTsmCmd = new UpdateTsmCmd(); String throughput = String.valueOf(Long.parseLong(capacityIOPs) * 4); updateTsmCmd.putCommandParameter("id", uuid); updateTsmCmd.putCommandParameter("iops", capacityIOPs); updateTsmCmd.putCommandParameter("throughput", throughput); UpdateTsmCmdResponse updateTsmStorageCmdResponse = (UpdateTsmCmdResponse) getElastistorRestClient() .executeCommand(updateTsmCmd); return updateTsmStorageCmdResponse; } private static final class UpdateTsmCmd extends BaseCommand { public UpdateTsmCmd() { super("updateTsm", new UpdateTsmCmdResponse()); } } public static final class UpdateTsmCmdResponse { @SerializedName("updateTsmResponse") private UpdateTsmWrapper tsmWrapper; public Tsm getTsm(int i) { return tsmWrapper.getTsm(i); } } public static final class UpdateTsmWrapper { @SerializedName("count") private int count; @SerializedName("tsm") private Tsm[] tsms; public int getCount() { return count; } public Tsm getTsm(int i) { return tsms[i]; } } }