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 java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; import java.util.StringTokenizer; import org.apache.commons.lang.StringUtils; import org.apache.log4j.Logger; import org.apache.cloudstack.storage.datastore.db.PrimaryDataStoreDao; import org.apache.cloudstack.storage.datastore.db.StoragePoolDetailVO; import org.apache.cloudstack.storage.datastore.db.StoragePoolDetailsDao; import org.apache.cloudstack.storage.datastore.db.StoragePoolVO; import com.cloud.dc.ClusterDetailsDao; import com.cloud.dc.ClusterDetailsVO; import com.cloud.dc.ClusterVO; import com.cloud.dc.dao.ClusterDao; import com.cloud.host.Host; import com.cloud.host.HostVO; import com.cloud.host.dao.HostDao; import com.cloud.user.AccountDetailVO; import com.cloud.user.AccountDetailsDao; import com.cloud.utils.db.GlobalLock; import com.cloud.utils.exception.CloudRuntimeException; import com.google.common.primitives.Longs; import com.solidfire.client.ElementFactory; import com.solidfire.element.api.Account; import com.solidfire.element.api.AddAccountRequest; import com.solidfire.element.api.CloneVolumeRequest; import com.solidfire.element.api.CloneVolumeResult; import com.solidfire.element.api.CreateSnapshotRequest; import com.solidfire.element.api.CreateVolumeAccessGroupRequest; import com.solidfire.element.api.CreateVolumeRequest; import com.solidfire.element.api.DeleteSnapshotRequest; import com.solidfire.element.api.DeleteVolumeRequest; import com.solidfire.element.api.GetAccountByIDRequest; import com.solidfire.element.api.GetAccountByNameRequest; import com.solidfire.element.api.GetAsyncResultRequest; import com.solidfire.element.api.ListSnapshotsRequest; import com.solidfire.element.api.ListVolumeAccessGroupsRequest; import com.solidfire.element.api.ListVolumesRequest; import com.solidfire.element.api.ModifyVolumeAccessGroupRequest; import com.solidfire.element.api.ModifyVolumeRequest; import com.solidfire.element.api.QoS; import com.solidfire.element.api.Snapshot; import com.solidfire.element.api.SolidFireElement; import com.solidfire.element.api.Volume; import com.solidfire.element.api.VolumeAccessGroup; import com.solidfire.jsvcgen.javautil.Optional; import static org.apache.commons.lang.ArrayUtils.toPrimitive; public class SolidFireUtil { private static final Logger s_logger = Logger.getLogger(SolidFireUtil.class); public static final String PROVIDER_NAME = "SolidFire"; public static final String SHARED_PROVIDER_NAME = "SolidFireShared"; public static final int s_lockTimeInSeconds = 300; public static final String LOG_PREFIX = "SolidFire: "; public static final String MANAGEMENT_VIP = "mVip"; public static final String STORAGE_VIP = "sVip"; public static final String MANAGEMENT_PORT = "mPort"; public static final String STORAGE_PORT = "sPort"; public static final String CLUSTER_ADMIN_USERNAME = "clusterAdminUsername"; public static final String CLUSTER_ADMIN_PASSWORD = "clusterAdminPassword"; // these three variables should only be used for the SolidFire plug-in with the name SolidFireUtil.PROVIDER_NAME public static final String CLUSTER_DEFAULT_MIN_IOPS = "clusterDefaultMinIops"; public static final String CLUSTER_DEFAULT_MAX_IOPS = "clusterDefaultMaxIops"; public static final String CLUSTER_DEFAULT_BURST_IOPS_PERCENT_OF_MAX_IOPS = "clusterDefaultBurstIopsPercentOfMaxIops"; // these three variables should only be used for the SolidFire plug-in with the name SolidFireUtil.SHARED_PROVIDER_NAME public static final String MIN_IOPS = "minIops"; public static final String MAX_IOPS = "maxIops"; public static final String BURST_IOPS = "burstIops"; private static final String ACCOUNT_ID = "accountId"; public static final String VOLUME_ID = "volumeId"; public static final String TEMP_VOLUME_ID = "tempVolumeId"; public static final String SNAPSHOT_ID = "snapshotId"; public static final String CloudStackVolumeId = "CloudStackVolumeId"; public static final String CloudStackVolumeSize = "CloudStackVolumeSize"; public static final String CloudStackSnapshotId = "CloudStackSnapshotId"; public static final String CloudStackSnapshotSize = "CloudStackSnapshotSize"; public static final String CloudStackTemplateId = "CloudStackTemplateId"; public static final String CloudStackTemplateSize = "CloudStackTemplateSize"; public static final String VOLUME_SIZE = "sfVolumeSize"; public static final String STORAGE_POOL_ID = "sfStoragePoolId"; public static final String DATACENTER = "datacenter"; public static final String DATASTORE_NAME = "datastoreName"; public static final String IQN = "iqn"; public static final long MAX_IOPS_PER_VOLUME = 100000; private static final int DEFAULT_MANAGEMENT_PORT = 443; private static final int DEFAULT_STORAGE_PORT = 3260; public static class SolidFireConnection { private final String _managementVip; private final int _managementPort; private final String _clusterAdminUsername; private final String _clusterAdminPassword; public SolidFireConnection(String managementVip, int managementPort, String clusterAdminUsername, String clusterAdminPassword) { if (managementVip == null) { throw new CloudRuntimeException("The management VIP cannot be 'null'."); } if (managementPort <= 0) { throw new CloudRuntimeException("The management port must be a positive integer."); } if (clusterAdminUsername == null) { throw new CloudRuntimeException("The cluster admin username cannot be 'null'."); } if (clusterAdminPassword == null) { throw new CloudRuntimeException("The cluster admin password cannot be 'null'."); } _managementVip = managementVip; _managementPort = managementPort; _clusterAdminUsername = clusterAdminUsername; _clusterAdminPassword = clusterAdminPassword; } String getManagementVip() { return _managementVip; } int getManagementPort() { return _managementPort; } String getClusterAdminUsername() { return _clusterAdminUsername; } private String getClusterAdminPassword() { return _clusterAdminPassword; } @Override public int hashCode() { return _managementVip.hashCode(); } @Override public boolean equals(Object obj) { if (!(obj instanceof SolidFireConnection)) { return false; } SolidFireConnection sfConnection = (SolidFireConnection) obj; return _managementVip.equals(sfConnection.getManagementVip()); } } public static SolidFireConnection getSolidFireConnection(long storagePoolId, StoragePoolDetailsDao storagePoolDetailsDao) { StoragePoolDetailVO storagePoolDetail = storagePoolDetailsDao.findDetail(storagePoolId, SolidFireUtil.MANAGEMENT_VIP); String mVip = storagePoolDetail.getValue(); storagePoolDetail = storagePoolDetailsDao.findDetail(storagePoolId, SolidFireUtil.MANAGEMENT_PORT); int mPort = Integer.parseInt(storagePoolDetail.getValue()); storagePoolDetail = storagePoolDetailsDao.findDetail(storagePoolId, SolidFireUtil.CLUSTER_ADMIN_USERNAME); String clusterAdminUsername = storagePoolDetail.getValue(); storagePoolDetail = storagePoolDetailsDao.findDetail(storagePoolId, SolidFireUtil.CLUSTER_ADMIN_PASSWORD); String clusterAdminPassword = storagePoolDetail.getValue(); return new SolidFireConnection(mVip, mPort, clusterAdminUsername, clusterAdminPassword); } private static SolidFireElement getSolidFireElement(SolidFireConnection sfConnection) { return ElementFactory.create(sfConnection.getManagementVip(), sfConnection.getClusterAdminUsername(), sfConnection.getClusterAdminPassword()); } // used to parse the "url" parameter when creating primary storage that's based on the SolidFire plug-in with the // name SolidFireUtil.PROVIDER_NAME (as opposed to the SolidFire plug-in with the name SolidFireUtil.SHARED_PROVIDER_NAME) // return a String instance that contains at most the MVIP and SVIP info public static String getModifiedUrl(String originalUrl) { StringBuilder sb = new StringBuilder(); String delimiter = ";"; StringTokenizer st = new StringTokenizer(originalUrl, delimiter); while (st.hasMoreElements()) { String token = st.nextElement().toString().toUpperCase(); if (token.startsWith(SolidFireUtil.MANAGEMENT_VIP.toUpperCase()) || token.startsWith(SolidFireUtil.STORAGE_VIP.toUpperCase())) { sb.append(token).append(delimiter); } } String modifiedUrl = sb.toString(); int lastIndexOf = modifiedUrl.lastIndexOf(delimiter); if (lastIndexOf == (modifiedUrl.length() - delimiter.length())) { return modifiedUrl.substring(0, lastIndexOf); } return modifiedUrl; } public static String getManagementVip(String url) { return getVip(SolidFireUtil.MANAGEMENT_VIP, url); } public static String getStorageVip(String url) { return getVip(SolidFireUtil.STORAGE_VIP, url); } public static int getManagementPort(String url) { return getPort(SolidFireUtil.MANAGEMENT_VIP, url, DEFAULT_MANAGEMENT_PORT); } public static int getStoragePort(String url) { return getPort(SolidFireUtil.STORAGE_VIP, url, DEFAULT_STORAGE_PORT); } public static String getValue(String keyToMatch, String url) { return getValue(keyToMatch, url, true); } public static String getValue(String keyToMatch, String url, boolean throwExceptionIfNotFound) { String delimiter1 = ";"; String delimiter2 = "="; StringTokenizer st = new StringTokenizer(url, delimiter1); while (st.hasMoreElements()) { String token = st.nextElement().toString(); int index = token.indexOf(delimiter2); if (index == -1) { throw new RuntimeException("Invalid URL format"); } String key = token.substring(0, index); if (key.equalsIgnoreCase(keyToMatch)) { return token.substring(index + delimiter2.length()); } } if (throwExceptionIfNotFound) { throw new RuntimeException("Key not found in URL"); } return null; } public static String getSolidFireAccountName(String csAccountUuid, long csAccountId) { return "CloudStack_" + csAccountUuid + "_" + csAccountId; } public static void updateCsDbWithSolidFireIopsInfo(long storagePoolId, PrimaryDataStoreDao primaryDataStoreDao, StoragePoolDetailsDao storagePoolDetailsDao, long minIops, long maxIops, long burstIops) { Map<String, String> existingDetails = storagePoolDetailsDao.listDetailsKeyPairs(storagePoolId); Set<String> existingKeys = existingDetails.keySet(); Map<String, String> existingDetailsToKeep = new HashMap<>(); for (String existingKey : existingKeys) { String existingValue = existingDetails.get(existingKey); if (!SolidFireUtil.MIN_IOPS.equalsIgnoreCase(existingValue) && !SolidFireUtil.MAX_IOPS.equalsIgnoreCase(existingValue) && !SolidFireUtil.BURST_IOPS.equalsIgnoreCase(existingValue)) { existingDetailsToKeep.put(existingKey, existingValue); } } existingDetailsToKeep.put(SolidFireUtil.MIN_IOPS, String.valueOf(minIops)); existingDetailsToKeep.put(SolidFireUtil.MAX_IOPS, String.valueOf(maxIops)); existingDetailsToKeep.put(SolidFireUtil.BURST_IOPS, String.valueOf(burstIops)); primaryDataStoreDao.updateDetails(storagePoolId, existingDetailsToKeep); } public static void updateCsDbWithSolidFireAccountInfo(long csAccountId, SolidFireUtil.SolidFireAccount sfAccount, long storagePoolId, AccountDetailsDao accountDetailsDao) { AccountDetailVO accountDetail = new AccountDetailVO(csAccountId, SolidFireUtil.getAccountKey(storagePoolId), String.valueOf(sfAccount.getId())); accountDetailsDao.persist(accountDetail); } public static SolidFireAccount getAccount(SolidFireConnection sfConnection, String sfAccountName) { try { return getAccountByName(sfConnection, sfAccountName); } catch (Exception ex) { return null; } } public static void hostAddedToOrRemovedFromCluster(long hostId, long clusterId, boolean added, String storageProvider, ClusterDao clusterDao, ClusterDetailsDao clusterDetailsDao, PrimaryDataStoreDao storagePoolDao, StoragePoolDetailsDao storagePoolDetailsDao, HostDao hostDao) { ClusterVO cluster = clusterDao.findById(clusterId); GlobalLock lock = GlobalLock.getInternLock(cluster.getUuid()); if (!lock.lock(s_lockTimeInSeconds)) { String errMsg = "Couldn't lock the DB on the following string: " + cluster.getUuid(); s_logger.debug(errMsg); throw new CloudRuntimeException(errMsg); } try { List<StoragePoolVO> storagePools = storagePoolDao.findPoolsByProvider(storageProvider); if (storagePools != null && storagePools.size() > 0) { List<SolidFireUtil.SolidFireConnection> sfConnections = new ArrayList<>(); for (StoragePoolVO storagePool : storagePools) { ClusterDetailsVO clusterDetail = clusterDetailsDao.findDetail(clusterId, SolidFireUtil.getVagKey(storagePool.getId())); String vagId = clusterDetail != null ? clusterDetail.getValue() : null; if (vagId != null) { SolidFireUtil.SolidFireConnection sfConnection = SolidFireUtil .getSolidFireConnection(storagePool.getId(), storagePoolDetailsDao); if (!sfConnections.contains(sfConnection)) { sfConnections.add(sfConnection); SolidFireUtil.SolidFireVag sfVag = SolidFireUtil.getVag(sfConnection, Long.parseLong(vagId)); List<HostVO> hostsToAddOrRemove = new ArrayList<>(); HostVO hostToAddOrRemove = hostDao.findByIdIncludingRemoved(hostId); hostsToAddOrRemove.add(hostToAddOrRemove); String[] hostIqns = SolidFireUtil.getNewHostIqns(sfVag.getInitiators(), SolidFireUtil.getIqnsFromHosts(hostsToAddOrRemove), added); SolidFireUtil.modifyVag(sfConnection, sfVag.getId(), hostIqns, sfVag.getVolumeIds()); } } } } } finally { lock.unlock(); lock.releaseRef(); } } public static long placeVolumeInVolumeAccessGroup(SolidFireConnection sfConnection, long sfVolumeId, long storagePoolId, String vagUuid, List<HostVO> hosts, ClusterDetailsDao clusterDetailsDao) { if (hosts == null || hosts.isEmpty()) { throw new CloudRuntimeException("There must be at least one host in the cluster."); } long lVagId; try { lVagId = SolidFireUtil.createVag(sfConnection, "CloudStack-" + vagUuid, SolidFireUtil.getIqnsFromHosts(hosts), new long[] { sfVolumeId }); } catch (Exception ex) { String iqnInVagAlready = "Exceeded maximum number of Volume Access Groups per initiator"; if (!ex.getMessage().contains(iqnInVagAlready)) { throw new CloudRuntimeException(ex.getMessage()); } // getCompatibleVag throws an exception if an existing VAG can't be located SolidFireUtil.SolidFireVag sfVag = getCompatibleVag(sfConnection, hosts); lVagId = sfVag.getId(); long[] volumeIds = getNewVolumeIds(sfVag.getVolumeIds(), sfVolumeId, true); SolidFireUtil.modifyVag(sfConnection, lVagId, sfVag.getInitiators(), volumeIds); } ClusterDetailsVO clusterDetail = new ClusterDetailsVO(hosts.get(0).getClusterId(), getVagKey(storagePoolId), String.valueOf(lVagId)); clusterDetailsDao.persist(clusterDetail); return lVagId; } public static boolean hostsSupport_iScsi(List<HostVO> hosts) { if (hosts == null || hosts.size() == 0) { return false; } for (Host host : hosts) { if (host == null || host.getStorageUrl() == null || host.getStorageUrl().trim().length() == 0 || !host.getStorageUrl().startsWith("iqn")) { return false; } } return true; } public static long[] getNewVolumeIds(long[] volumeIds, long volumeIdToAddOrRemove, boolean add) { if (add) { return getNewVolumeIdsAdd(volumeIds, volumeIdToAddOrRemove); } return getNewVolumeIdsRemove(volumeIds, volumeIdToAddOrRemove); } public static String getVagKey(long storagePoolId) { return "sfVolumeAccessGroup_" + storagePoolId; } public static String getAccountKey(long storagePoolId) { return SolidFireUtil.ACCOUNT_ID + "_" + storagePoolId; } public static AccountDetailVO getAccountDetail(long csAccountId, long storagePoolId, AccountDetailsDao accountDetailsDao) { AccountDetailVO accountDetail = accountDetailsDao.findDetail(csAccountId, SolidFireUtil.getAccountKey(storagePoolId)); if (accountDetail == null || accountDetail.getValue() == null) { accountDetail = accountDetailsDao.findDetail(csAccountId, SolidFireUtil.ACCOUNT_ID); } return accountDetail; } public static String getSolidFireVolumeName(String strCloudStackVolumeName) { final String specialChar = "-"; StringBuilder strSolidFireVolumeName = new StringBuilder(); for (int i = 0; i < strCloudStackVolumeName.length(); i++) { String strChar = strCloudStackVolumeName.substring(i, i + 1); if (StringUtils.isAlphanumeric(strChar)) { strSolidFireVolumeName.append(strChar); } else { strSolidFireVolumeName.append(specialChar); } } return strSolidFireVolumeName.toString(); } public static long createVolume(SolidFireConnection sfConnection, String volumeName, long accountId, long totalSize, boolean enable512e, Map<String, String> mapAttributes, long minIops, long maxIops, long burstIops) { CreateVolumeRequest request = CreateVolumeRequest.builder().name(volumeName).accountID(accountId) .totalSize(totalSize).enable512e(enable512e).optionalAttributes(convertMap(mapAttributes)) .optionalQos(new QoS(Optional.of(minIops), Optional.of(maxIops), Optional.of(burstIops), Optional.EMPTY_LONG)) .build(); return getSolidFireElement(sfConnection).createVolume(request).getVolumeID(); } public static void modifyVolume(SolidFireConnection sfConnection, long volumeId, Long totalSize, Map<String, String> mapAttributes, long minIops, long maxIops, long burstIops) { ModifyVolumeRequest request = ModifyVolumeRequest.builder().volumeID(volumeId).optionalTotalSize(totalSize) .optionalAttributes(convertMap(mapAttributes)).optionalQos(new QoS(Optional.of(minIops), Optional.of(maxIops), Optional.of(burstIops), Optional.EMPTY_LONG)) .build(); getSolidFireElement(sfConnection).modifyVolume(request); } public static SolidFireVolume getVolume(SolidFireConnection sfConnection, long volumeId) { ListVolumesRequest request = ListVolumesRequest.builder().optionalStartVolumeID(volumeId).optionalLimit(1L) .build(); Volume volume = getSolidFireElement(sfConnection).listVolumes(request).getVolumes()[0]; return new SolidFireVolume(volume.getVolumeID(), volume.getName(), volume.getIqn(), volume.getAccountID(), volume.getStatus(), volume.getEnable512e(), volume.getQos().getMinIOPS(), volume.getQos().getMaxIOPS(), volume.getQos().getBurstIOPS(), volume.getTotalSize()); } public static void deleteVolume(SolidFireConnection sfConnection, long volumeId) { DeleteVolumeRequest request = DeleteVolumeRequest.builder().volumeID(volumeId).build(); getSolidFireElement(sfConnection).deleteVolume(request); } private static final String ACTIVE = "active"; public static class SolidFireVolume { private final long _id; private final String _name; private final String _iqn; private final long _accountId; private final String _status; private final boolean _enable512e; private final long _minIops; private final long _maxIops; private final long _burstIops; private final long _totalSize; SolidFireVolume(long id, String name, String iqn, long accountId, String status, boolean enable512e, long minIops, long maxIops, long burstIops, long totalSize) { _id = id; _name = name; _iqn = "/" + iqn + "/0"; _accountId = accountId; _status = status; _enable512e = enable512e; _minIops = minIops; _maxIops = maxIops; _burstIops = burstIops; _totalSize = totalSize; } public long getId() { return _id; } public String getName() { return _name; } public String getIqn() { return _iqn; } public long getAccountId() { return _accountId; } public boolean isActive() { return ACTIVE.equalsIgnoreCase(_status); } public boolean isEnable512e() { return _enable512e; } public long getMinIops() { return _minIops; } public long getMaxIops() { return _maxIops; } public long getBurstIops() { return _burstIops; } public long getTotalSize() { return _totalSize; } @Override public int hashCode() { return _iqn.hashCode(); } @Override public String toString() { return _name; } @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (!obj.getClass().equals(SolidFireVolume.class)) { return false; } SolidFireVolume sfv = (SolidFireVolume) obj; return _id == sfv._id && _name.equals(sfv._name) && _iqn.equals(sfv._iqn) && _accountId == sfv._accountId && isActive() == sfv.isActive() && getTotalSize() == sfv.getTotalSize(); } } public static long createSnapshot(SolidFireConnection sfConnection, long volumeId, String snapshotName, Map<String, String> mapAttributes) { CreateSnapshotRequest request = CreateSnapshotRequest.builder().volumeID(volumeId) .optionalName(snapshotName).optionalAttributes(convertMap(mapAttributes)).build(); return getSolidFireElement(sfConnection).createSnapshot(request).getSnapshotID(); } public static SolidFireSnapshot getSnapshot(SolidFireConnection sfConnection, long volumeId, long snapshotId) { ListSnapshotsRequest request = ListSnapshotsRequest.builder().optionalVolumeID(volumeId).build(); Snapshot[] snapshots = getSolidFireElement(sfConnection).listSnapshots(request).getSnapshots(); String snapshotName = null; if (snapshots != null) { for (Snapshot snapshot : snapshots) { if (snapshot.getSnapshotID() == snapshotId) { snapshotName = snapshot.getName(); break; } } } if (snapshotName == null) { throw new CloudRuntimeException("Could not find SolidFire snapshot ID: " + snapshotId + " for the following SolidFire volume ID: " + volumeId); } return new SolidFireSnapshot(snapshotId, snapshotName); } public static void deleteSnapshot(SolidFireConnection sfConnection, long snapshotId) { DeleteSnapshotRequest request = DeleteSnapshotRequest.builder().snapshotID(snapshotId).build(); getSolidFireElement(sfConnection).deleteSnapshot(request); } public static class SolidFireSnapshot { private final long _id; private final String _name; SolidFireSnapshot(long id, String name) { _id = id; _name = name; } public long getId() { return _id; } public String getName() { return _name; } } public static long createClone(SolidFireConnection sfConnection, long volumeId, long snapshotId, long accountId, String cloneName, Map<String, String> mapAttributes) { CloneVolumeRequest request = CloneVolumeRequest.builder().volumeID(volumeId) .optionalSnapshotID(snapshotId < 1 ? null : snapshotId).optionalNewAccountID(accountId) .name(cloneName).optionalAttributes(convertMap(mapAttributes)).build(); CloneVolumeResult result = getSolidFireElement(sfConnection).cloneVolume(request); // Clone is an async operation. Poll until we get data. GetAsyncResultRequest asyncResultRequest = GetAsyncResultRequest.builder() .asyncHandle(result.getAsyncHandle()).build(); do { String status = getSolidFireElement(sfConnection).getAsyncResult(asyncResultRequest).getStatus(); if (status.equals("complete")) { break; } try { Thread.sleep(500); // sleep for 1/2 of a second } catch (Exception ex) { // ignore } } while (true); return result.getVolumeID(); } public static long createAccount(SolidFireConnection sfConnection, String accountName) { AddAccountRequest request = AddAccountRequest.builder().username(accountName).build(); return getSolidFireElement(sfConnection).addAccount(request).getAccountID(); } public static SolidFireAccount getAccountById(SolidFireConnection sfConnection, long accountId) { GetAccountByIDRequest request = GetAccountByIDRequest.builder().accountID(accountId).build(); Account sfAccount = getSolidFireElement(sfConnection).getAccountByID(request).getAccount(); String sfAccountName = sfAccount.getUsername(); String sfAccountInitiatorSecret = sfAccount.getInitiatorSecret().isPresent() ? sfAccount.getInitiatorSecret().get().toString() : ""; String sfAccountTargetSecret = sfAccount.getTargetSecret().isPresent() ? sfAccount.getTargetSecret().get().toString() : ""; return new SolidFireAccount(accountId, sfAccountName, sfAccountInitiatorSecret, sfAccountTargetSecret); } private static SolidFireAccount getAccountByName(SolidFireConnection sfConnection, String accountName) { GetAccountByNameRequest request = GetAccountByNameRequest.builder().username(accountName).build(); Account sfAccount = getSolidFireElement(sfConnection).getAccountByName(request).getAccount(); long sfAccountId = sfAccount.getAccountID(); String sfAccountInitiatorSecret = sfAccount.getInitiatorSecret().isPresent() ? sfAccount.getInitiatorSecret().get().toString() : ""; String sfAccountTargetSecret = sfAccount.getTargetSecret().isPresent() ? sfAccount.getTargetSecret().get().toString() : ""; return new SolidFireAccount(sfAccountId, accountName, sfAccountInitiatorSecret, sfAccountTargetSecret); } public static class SolidFireAccount { private final long _id; private final String _name; private final String _initiatorSecret; private final String _targetSecret; SolidFireAccount(long id, String name, String initiatorSecret, String targetSecret) { _id = id; _name = name; _initiatorSecret = initiatorSecret; _targetSecret = targetSecret; } public long getId() { return _id; } public String getName() { return _name; } @Override public int hashCode() { return (_id + _name).hashCode(); } @Override public String toString() { return _name; } @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (!obj.getClass().equals(SolidFireAccount.class)) { return false; } SolidFireAccount sfa = (SolidFireAccount) obj; return _id == sfa._id && _name.equals(sfa._name) && _initiatorSecret.equals(sfa._initiatorSecret) && _targetSecret.equals(sfa._targetSecret); } } private static long createVag(SolidFireConnection sfConnection, String vagName, String[] iqns, long[] volumeIds) { CreateVolumeAccessGroupRequest request = CreateVolumeAccessGroupRequest.builder().name(vagName) .optionalInitiators(iqns) .optionalVolumes(Longs.asList(volumeIds).toArray(new Long[volumeIds.length])).build(); return getSolidFireElement(sfConnection).createVolumeAccessGroup(request).getVolumeAccessGroupID(); } public static void modifyVag(SolidFireConnection sfConnection, long vagId, String[] iqns, long[] volumeIds) { ModifyVolumeAccessGroupRequest request = ModifyVolumeAccessGroupRequest.builder().volumeAccessGroupID(vagId) .optionalInitiators(iqns) .optionalVolumes(Longs.asList(volumeIds).toArray(new Long[volumeIds.length])).build(); getSolidFireElement(sfConnection).modifyVolumeAccessGroup(request); } public static SolidFireVag getVag(SolidFireConnection sfConnection, long vagId) { ListVolumeAccessGroupsRequest request = ListVolumeAccessGroupsRequest.builder() .optionalStartVolumeAccessGroupID(vagId).optionalLimit(1L).build(); VolumeAccessGroup vag = getSolidFireElement(sfConnection).listVolumeAccessGroups(request) .getVolumeAccessGroups()[0]; String[] vagIqns = vag.getInitiators(); long[] vagVolumeIds = toPrimitive(vag.getVolumes()); return new SolidFireVag(vagId, vagIqns, vagVolumeIds); } private static List<SolidFireVag> getAllVags(SolidFireConnection sfConnection) { ListVolumeAccessGroupsRequest request = ListVolumeAccessGroupsRequest.builder().build(); VolumeAccessGroup[] vags = getSolidFireElement(sfConnection).listVolumeAccessGroups(request) .getVolumeAccessGroups(); List<SolidFireVag> lstSolidFireVags = new ArrayList<>(); if (vags != null) { for (VolumeAccessGroup vag : vags) { SolidFireVag sfVag = new SolidFireVag(vag.getVolumeAccessGroupID(), vag.getInitiators(), toPrimitive(vag.getVolumes())); lstSolidFireVags.add(sfVag); } } return lstSolidFireVags; } public static class SolidFireVag { private final long _id; private final String[] _initiators; private final long[] _volumeIds; SolidFireVag(long id, String[] initiators, long[] volumeIds) { _id = id; _initiators = initiators; _volumeIds = volumeIds; } public long getId() { return _id; } public String[] getInitiators() { return _initiators; } public long[] getVolumeIds() { return _volumeIds; } @Override public int hashCode() { return String.valueOf(_id).hashCode(); } @Override public String toString() { return String.valueOf(_id); } @Override public boolean equals(Object obj) { if (obj == null) { return false; } if (!obj.getClass().equals(SolidFireVag.class)) { return false; } SolidFireVag sfVag = (SolidFireVag) obj; return _id == sfVag._id; } } private static String getVip(String keyToMatch, String url) { String delimiter = ":"; String storageVip = getValue(keyToMatch, url); int index = storageVip.indexOf(delimiter); if (index != -1) { return storageVip.substring(0, index); } return storageVip; } private static int getPort(String keyToMatch, String url, int defaultPortNumber) { String delimiter = ":"; String storageVip = getValue(keyToMatch, url); int index = storageVip.indexOf(delimiter); int portNumber = defaultPortNumber; if (index != -1) { String port = storageVip.substring(index + delimiter.length()); try { portNumber = Integer.parseInt(port); } catch (NumberFormatException ex) { throw new IllegalArgumentException("Invalid URL format (port is not an integer)"); } } return portNumber; } private static String[] getNewHostIqns(String[] iqns, String[] iqnsToAddOrRemove, boolean add) { if (add) { return getNewHostIqnsAdd(iqns, iqnsToAddOrRemove); } return getNewHostIqnsRemove(iqns, iqnsToAddOrRemove); } private static String[] getNewHostIqnsAdd(String[] iqns, String[] iqnsToAdd) { List<String> lstIqns = iqns != null ? new ArrayList<>(Arrays.asList(iqns)) : new ArrayList<String>(); if (iqnsToAdd != null) { for (String iqnToAdd : iqnsToAdd) { if (!lstIqns.contains(iqnToAdd)) { lstIqns.add(iqnToAdd); } } } return lstIqns.toArray(new String[0]); } private static String[] getNewHostIqnsRemove(String[] iqns, String[] iqnsToRemove) { List<String> lstIqns = iqns != null ? new ArrayList<>(Arrays.asList(iqns)) : new ArrayList<String>(); if (iqnsToRemove != null) { for (String iqnToRemove : iqnsToRemove) { lstIqns.remove(iqnToRemove); } } return lstIqns.toArray(new String[0]); } private static long[] getNewVolumeIdsAdd(long[] volumeIds, long volumeIdToAdd) { List<Long> lstVolumeIds = new ArrayList<>(); if (volumeIds != null) { for (long volumeId : volumeIds) { lstVolumeIds.add(volumeId); } } if (lstVolumeIds.contains(volumeIdToAdd)) { return volumeIds; } lstVolumeIds.add(volumeIdToAdd); return toPrimitive(lstVolumeIds.toArray(new Long[lstVolumeIds.size()])); } private static long[] getNewVolumeIdsRemove(long[] volumeIds, long volumeIdToRemove) { List<Long> lstVolumeIds = new ArrayList<>(); if (volumeIds != null) { for (long volumeId : volumeIds) { lstVolumeIds.add(volumeId); } } lstVolumeIds.remove(volumeIdToRemove); return toPrimitive(lstVolumeIds.toArray(new Long[lstVolumeIds.size()])); } private static String[] getIqnsFromHosts(List<? extends Host> hosts) { if (hosts == null || hosts.size() == 0) { throw new CloudRuntimeException("There do not appear to be any hosts in this cluster."); } List<String> lstIqns = new ArrayList<>(); for (Host host : hosts) { lstIqns.add(host.getStorageUrl()); } return lstIqns.toArray(new String[0]); } // this method takes in a collection of hosts and tries to find an existing VAG that has all of them in it // if successful, the VAG is returned; else, a CloudRuntimeException is thrown and this issue should be corrected by an admin private static SolidFireUtil.SolidFireVag getCompatibleVag(SolidFireConnection sfConnection, List<HostVO> hosts) { List<SolidFireUtil.SolidFireVag> sfVags = SolidFireUtil.getAllVags(sfConnection); if (sfVags != null) { List<String> hostIqns = new ArrayList<>(); // where the method we're in is called, hosts should not be null for (HostVO host : hosts) { // where the method we're in is called, host.getStorageUrl() should not be null (it actually should start with "iqn") hostIqns.add(host.getStorageUrl().toLowerCase()); } for (SolidFireUtil.SolidFireVag sfVag : sfVags) { List<String> lstInitiators = getStringArrayAsLowerCaseStringList(sfVag.getInitiators()); // lstInitiators should not be returned from getStringArrayAsLowerCaseStringList as null if (lstInitiators.containsAll(hostIqns)) { return sfVag; } } } throw new CloudRuntimeException("Unable to locate the appropriate SolidFire Volume Access Group"); } private static List<String> getStringArrayAsLowerCaseStringList(String[] aString) { List<String> lstLowerCaseString = new ArrayList<>(); if (aString != null) { for (String str : aString) { if (str != null) { lstLowerCaseString.add(str.toLowerCase()); } } } return lstLowerCaseString; } private static Map<String, Object> convertMap(Map<String, String> map) { if (map == null) { return null; } Map<String, Object> convertedMap = new HashMap<>(); convertedMap.putAll(map); return convertedMap; } }