etan39
/
cloudstack
mirror of https://github.com/apache/cloudstack.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
cloudstack/engine/schema/src/com/cloud/upgrade/dao/Upgrade410to420.java

3020 lines
140 KiB
Java
Executable File
Raw Blame History

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package com.cloud.upgrade.dao;
import java.io.File;
import java.io.UnsupportedEncodingException;
import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import org.apache.log4j.Logger;
import org.apache.cloudstack.api.ApiConstants;
import org.apache.cloudstack.engine.subsystem.api.storage.DataStoreProvider;
import com.cloud.deploy.DeploymentPlanner;
import com.cloud.hypervisor.Hypervisor.HypervisorType;
import com.cloud.network.vpc.NetworkACL;
import com.cloud.utils.Pair;
import com.cloud.utils.crypt.DBEncryptionUtil;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.script.Script;
public class Upgrade410to420 implements DbUpgrade {
final static Logger s_logger = Logger.getLogger(Upgrade410to420.class);
@Override
public String[] getUpgradableVersionRange() {
return new String[] {"4.1.0", "4.2.0"};
}
@Override
public String getUpgradedVersion() {
return "4.2.0";
}
@Override
public boolean supportsRollingUpgrade() {
return false;
}
@Override
public File[] getPrepareScripts() {
String script = Script.findScript("", "db/schema-410to420.sql");
if (script == null) {
throw new CloudRuntimeException("Unable to find db/schema-410to420.sql");
}
return new File[] {new File(script)};
}
@Override
public void performDataMigration(Connection conn) {
movePrivateZoneToDedicatedResource(conn);
upgradeVmwareLabels(conn);
persistLegacyZones(conn);
persistVswitchConfiguration(conn);
createPlaceHolderNics(conn);
updateRemoteAccessVpn(conn);
updateOverCommitRatioClusterDetails(conn);
updatePrimaryStore(conn);
addEgressFwRulesForSRXGuestNw(conn);
upgradeEIPNetworkOfferings(conn);
updateGlobalDeploymentPlanner(conn);
upgradeDefaultVpcOffering(conn);
upgradePhysicalNtwksWithInternalLbProvider(conn);
updateNetworkACLs(conn);
addHostDetailsIndex(conn);
updateNetworksForPrivateGateways(conn);
correctExternalNetworkDevicesSetup(conn);
removeFirewallServiceFromSharedNetworkOfferingWithSGService(conn);
fix22xKVMSnapshots(conn);
setKVMSnapshotFlag(conn);
addIndexForAlert(conn);
fixBaremetalForeignKeys(conn);
// storage refactor related migration
// TODO: add clean-up scripts to delete the deprecated table.
migrateSecondaryStorageToImageStore(conn);
migrateVolumeHostRef(conn);
migrateTemplateHostRef(conn);
migrateSnapshotStoreRef(conn);
migrateS3ToImageStore(conn);
migrateSwiftToImageStore(conn);
fixNiciraKeys(conn);
fixRouterKeys(conn);
encryptSite2SitePSK(conn);
migrateDatafromIsoIdInVolumesTable(conn);
setRAWformatForRBDVolumes(conn);
migrateVolumeOnSecondaryStorage(conn);
createFullCloneFlag(conn);
upgradeVpcServiceMap(conn);
upgradeResourceCount(conn);
}
private void createFullCloneFlag(Connection conn) {
ResultSet rs = null;
PreparedStatement delete = null;
PreparedStatement query = null;
PreparedStatement update = null;
int numRows = 0;
try {
delete = conn.prepareStatement("delete from `cloud`.`configuration` where name='vmware.create.full.clone';");
delete.executeUpdate();
query = conn.prepareStatement("select count(*) from `cloud`.`data_center`");
rs = query.executeQuery();
if (rs.next()) {
numRows = rs.getInt(1);
}
if (numRows > 0) {
update =
conn.prepareStatement("insert into `cloud`.`configuration` (`category`, `instance`, `component`, `name`, `value`, `description`) VALUES ('Advanced', 'DEFAULT', 'UserVmManager', 'vmware.create.full.clone' , 'false', 'If set to true, creates VMs as full clones on ESX hypervisor');");
} else {
update =
conn.prepareStatement("insert into `cloud`.`configuration` (`category`, `instance`, `component`, `name`, `value`, `description`) VALUES ('Advanced', 'DEFAULT', 'UserVmManager', 'vmware.create.full.clone' , 'true', 'If set to true, creates VMs as full clones on ESX hypervisor');");
}
update.executeUpdate();
} catch (SQLException e) {
throw new CloudRuntimeException("Failed to set global flag vmware.create.full.clone: ", e);
} finally {
if (update != null) {
try {
update.close();
} catch (SQLException e) {
}
}
if (query != null) {
try {
query.close();
} catch (SQLException e) {
}
}
if (delete != null) {
try {
delete.close();
} catch (SQLException e) {
}
}
}
}
private void migrateVolumeOnSecondaryStorage(Connection conn) {
PreparedStatement sql = null;
try {
sql = conn.prepareStatement("update `cloud`.`volumes` set state='Uploaded' where state='UploadOp'");
sql.executeUpdate();
} catch (SQLException e) {
throw new CloudRuntimeException("Failed to upgrade volume state: ", e);
} finally {
if (sql != null) {
try {
sql.close();
} catch (SQLException e) {
}
}
}
}
private void persistVswitchConfiguration(Connection conn) {
PreparedStatement clustersQuery = null;
ResultSet clusters = null;
Long clusterId;
String clusterHypervisorType;
final String NEXUS_GLOBAL_CONFIG_PARAM_NAME = "vmware.use.nexus.vswitch";
final String DVS_GLOBAL_CONFIG_PARAM_NAME = "vmware.use.dvswitch";
final String VSWITCH_GLOBAL_CONFIG_PARAM_CATEGORY = "Network";
final String VMWARE_STANDARD_VSWITCH = "vmwaresvs";
final String NEXUS_1000V_DVSWITCH = "nexusdvs";
String paramValStr;
boolean readGlobalConfigParam = false;
boolean nexusEnabled = false;
String publicVswitchType = VMWARE_STANDARD_VSWITCH;
String guestVswitchType = VMWARE_STANDARD_VSWITCH;
Map<Long, List<Pair<String, String>>> detailsMap = new HashMap<Long, List<Pair<String, String>>>();
List<Pair<String, String>> detailsList;
try {
clustersQuery = conn.prepareStatement("select id, hypervisor_type from `cloud`.`cluster` where removed is NULL");
clusters = clustersQuery.executeQuery();
while (clusters.next()) {
clusterHypervisorType = clusters.getString("hypervisor_type");
clusterId = clusters.getLong("id");
if (clusterHypervisorType.equalsIgnoreCase("VMware")) {
if (!readGlobalConfigParam) {
paramValStr = getConfigurationParameter(conn, VSWITCH_GLOBAL_CONFIG_PARAM_CATEGORY, NEXUS_GLOBAL_CONFIG_PARAM_NAME);
if (paramValStr.equalsIgnoreCase("true")) {
nexusEnabled = true;
}
}
if (nexusEnabled) {
publicVswitchType = NEXUS_1000V_DVSWITCH;
guestVswitchType = NEXUS_1000V_DVSWITCH;
}
detailsList = new ArrayList<Pair<String, String>>();
detailsList.add(new Pair<String, String>(ApiConstants.VSWITCH_TYPE_GUEST_TRAFFIC, guestVswitchType));
detailsList.add(new Pair<String, String>(ApiConstants.VSWITCH_TYPE_PUBLIC_TRAFFIC, publicVswitchType));
detailsMap.put(clusterId, detailsList);
updateClusterDetails(conn, detailsMap);
s_logger.debug("Persist vSwitch Configuration: Successfully persisted vswitch configuration for cluster " + clusterId);
} else {
s_logger.debug("Persist vSwitch Configuration: Ignoring cluster " + clusterId + " with hypervisor type " + clusterHypervisorType);
continue;
}
} // End cluster iteration
if (nexusEnabled) {
// If Nexus global parameter is true, then set DVS configuration parameter to true. TODOS: Document that this mandates that MS need to be restarted.
setConfigurationParameter(conn, VSWITCH_GLOBAL_CONFIG_PARAM_CATEGORY, DVS_GLOBAL_CONFIG_PARAM_NAME, "true");
}
} catch (SQLException e) {
String msg = "Unable to persist vswitch configuration of VMware clusters." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (clusters != null) {
clusters.close();
}
if (clustersQuery != null) {
clustersQuery.close();
}
} catch (SQLException e) {
}
}
}
private void updateClusterDetails(Connection conn, Map<Long, List<Pair<String, String>>> detailsMap) {
PreparedStatement clusterDetailsInsert = null;
// Insert cluster details into cloud.cluster_details table for existing VMware clusters
// Input parameter detailMap is a map of clusterId and list of key value pairs for that cluster
Long clusterId;
String key;
String val;
List<Pair<String, String>> keyValues;
try {
Iterator<Long> clusterIt = detailsMap.keySet().iterator();
while (clusterIt.hasNext()) {
clusterId = clusterIt.next();
keyValues = detailsMap.get(clusterId);
for (Pair<String, String> keyValuePair : keyValues) {
clusterDetailsInsert = conn.prepareStatement("INSERT INTO `cloud`.`cluster_details` (cluster_id, name, value) VALUES (?, ?, ?)");
key = keyValuePair.first();
val = keyValuePair.second();
clusterDetailsInsert.setLong(1, clusterId);
clusterDetailsInsert.setString(2, key);
clusterDetailsInsert.setString(3, val);
clusterDetailsInsert.executeUpdate();
}
s_logger.debug("Inserted vswitch configuration details into cloud.cluster_details for cluster with id " + clusterId + ".");
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable insert cluster details into cloud.cluster_details table.", e);
} finally {
try {
if (clusterDetailsInsert != null) {
clusterDetailsInsert.close();
}
} catch (SQLException e) {
}
}
}
private String getConfigurationParameter(Connection conn, String category, String paramName) {
ResultSet rs = null;
PreparedStatement pstmt = null;
try {
pstmt =
conn.prepareStatement("select value from `cloud`.`configuration` where category='" + category + "' and value is not NULL and name = '" + paramName + "';");
rs = pstmt.executeQuery();
while (rs.next()) {
return rs.getString("value");
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable read global configuration parameter " + paramName + ". ", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
return "false";
}
private void setConfigurationParameter(Connection conn, String category, String paramName, String paramVal) {
PreparedStatement pstmt = null;
try {
pstmt = conn.prepareStatement("UPDATE `cloud`.`configuration` SET value = '" + paramVal + "' WHERE name = '" + paramName + "';");
s_logger.debug("Updating global configuration parameter " + paramName + " with value " + paramVal + ". Update SQL statement is " + pstmt);
pstmt.executeUpdate();
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to set global configuration parameter " + paramName + " to " + paramVal + ". ", e);
} finally {
try {
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void movePrivateZoneToDedicatedResource(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
PreparedStatement pstmtUpdate = null;
PreparedStatement pstmt3 = null;
ResultSet rs3 = null;
try {
pstmt3 = conn.prepareStatement("SELECT distinct(`domain_id`) FROM `cloud`.`data_center` WHERE `domain_id` IS NOT NULL AND removed IS NULL");
rs3 = pstmt3.executeQuery();
while (rs3.next()) {
long domainId = rs3.getLong(1);
long affinityGroupId = 0;
// create or find an affinity group for this domain of type
// 'ExplicitDedication'
PreparedStatement pstmt2 = null;
ResultSet rs2 = null;
pstmt2 =
conn.prepareStatement("SELECT affinity_group.id FROM `cloud`.`affinity_group` INNER JOIN `cloud`.`affinity_group_domain_map` ON affinity_group.id=affinity_group_domain_map.affinity_group_id WHERE affinity_group.type = 'ExplicitDedication' AND affinity_group.acl_type = 'Domain' AND (affinity_group_domain_map.domain_id = ?)");
pstmt2.setLong(1, domainId);
rs2 = pstmt2.executeQuery();
if (rs2.next()) {
// group exists, use it
affinityGroupId = rs2.getLong(1);
} else {
// create new group
rs2.close();
pstmt2.close();
pstmt2 = conn.prepareStatement("SELECT name FROM `cloud`.`domain` where id = ?");
pstmt2.setLong(1, domainId);
rs2 = pstmt2.executeQuery();
String domainName = "";
if (rs2.next()) {
domainName = rs2.getString(1);
}
rs2.close();
pstmt2.close();
// create new domain level group for this domain
String type = "ExplicitDedication";
String uuid = UUID.randomUUID().toString();
String groupName = "DedicatedGrp-domain-" + domainName;
s_logger.debug("Adding AffinityGroup of type " + type + " for domain id " + domainId);
String sql =
"INSERT INTO `cloud`.`affinity_group` (`name`, `type`, `uuid`, `description`, `domain_id`, `account_id`, `acl_type`) VALUES (?, ?, ?, ?, 1, 1, 'Domain')";
pstmtUpdate = conn.prepareStatement(sql);
pstmtUpdate.setString(1, groupName);
pstmtUpdate.setString(2, type);
pstmtUpdate.setString(3, uuid);
pstmtUpdate.setString(4, "dedicated resources group");
pstmtUpdate.executeUpdate();
pstmtUpdate.close();
pstmt2 = conn.prepareStatement("SELECT affinity_group.id FROM `cloud`.`affinity_group` where uuid = ?");
pstmt2.setString(1, uuid);
rs2 = pstmt2.executeQuery();
if (rs2.next()) {
affinityGroupId = rs2.getLong(1);
}
// add the domain map
String sqlMap = "INSERT INTO `cloud`.`affinity_group_domain_map` (`domain_id`, `affinity_group_id`) VALUES (?, ?)";
pstmtUpdate = conn.prepareStatement(sqlMap);
pstmtUpdate.setLong(1, domainId);
pstmtUpdate.setLong(2, affinityGroupId);
pstmtUpdate.executeUpdate();
pstmtUpdate.close();
}
rs2.close();
pstmt2.close();
pstmt = conn.prepareStatement("SELECT `id` FROM `cloud`.`data_center` WHERE `domain_id` = ? AND removed IS NULL");
pstmt.setLong(1, domainId);
rs = pstmt.executeQuery();
while (rs.next()) {
long zoneId = rs.getLong(1);
dedicateZone(conn, zoneId, domainId, affinityGroupId);
}
}
} catch (SQLException e) {
throw new CloudRuntimeException("Exception while Moving private zone information to dedicated resources", e);
} finally {
if (pstmtUpdate != null) {
try {
pstmtUpdate.close();
} catch (SQLException e) {
}
}
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
}
}
if (pstmt != null) {
try {
pstmt.close();
} catch (SQLException e) {
}
}
if (rs3 != null) {
try {
rs3.close();
} catch (SQLException e) {
}
}
if (pstmt3 != null) {
try {
pstmt3.close();
} catch (SQLException e) {
}
}
}
}
private void dedicateZone(Connection conn, long zoneId, long domainId, long affinityGroupId) {
PreparedStatement pstmtUpdate2 = null;
try {
// create the dedicated resources entry
String sql = "INSERT INTO `cloud`.`dedicated_resources` (`uuid`,`data_center_id`, `domain_id`, `affinity_group_id`) VALUES (?, ?, ?, ?)";
pstmtUpdate2 = conn.prepareStatement(sql);
pstmtUpdate2.setString(1, UUID.randomUUID().toString());
pstmtUpdate2.setLong(2, zoneId);
pstmtUpdate2.setLong(3, domainId);
pstmtUpdate2.setLong(4, affinityGroupId);
pstmtUpdate2.executeUpdate();
pstmtUpdate2.close();
} catch (SQLException e) {
throw new CloudRuntimeException("Exception while saving zone to dedicated resources", e);
} finally {
if (pstmtUpdate2 != null) {
try {
pstmtUpdate2.close();
} catch (SQLException e) {
}
}
}
}
private void fixBaremetalForeignKeys(Connection conn) {
List<String> keys = new ArrayList<String>();
keys.add("fk_external_dhcp_devices_nsp_id");
keys.add("fk_external_dhcp_devices_host_id");
keys.add("fk_external_dhcp_devices_pod_id");
keys.add("fk_external_dhcp_devices_physical_network_id");
DbUpgradeUtils.dropKeysIfExist(conn, "baremetal_dhcp_devices", keys, true);
keys.add("fk_external_pxe_devices_nsp_id");
keys.add("fk_external_pxe_devices_host_id");
keys.add("fk_external_pxe_devices_physical_network_id");
DbUpgradeUtils.dropKeysIfExist(conn, "baremetal_pxe_devices", keys, true);
PreparedStatement pstmt = null;
try {
pstmt =
conn.prepareStatement("ALTER TABLE `cloud`.`baremetal_dhcp_devices` ADD CONSTRAINT `fk_external_dhcp_devices_nsp_id` FOREIGN KEY (`nsp_id`) REFERENCES `physical_network_service_providers` (`id`) ON DELETE CASCADE");
pstmt.executeUpdate();
pstmt.close();
pstmt =
conn.prepareStatement("ALTER TABLE `cloud`.`baremetal_dhcp_devices` ADD CONSTRAINT `fk_external_dhcp_devices_host_id` FOREIGN KEY (`host_id`) REFERENCES `host`(`id`) ON DELETE CASCADE");
pstmt.executeUpdate();
pstmt.close();
pstmt.close();
pstmt =
conn.prepareStatement("ALTER TABLE `cloud`.`baremetal_dhcp_devices` ADD CONSTRAINT `fk_external_dhcp_devices_physical_network_id` FOREIGN KEY (`physical_network_id`) REFERENCES `physical_network`(`id`) ON DELETE CASCADE");
pstmt.executeUpdate();
pstmt.close();
s_logger.debug("Added foreign keys for table baremetal_dhcp_devices");
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to add foreign keys to baremetal_dhcp_devices table", e);
}
try {
pstmt =
conn.prepareStatement("ALTER TABLE `cloud`.`baremetal_pxe_devices` ADD CONSTRAINT `fk_external_pxe_devices_nsp_id` FOREIGN KEY (`nsp_id`) REFERENCES `physical_network_service_providers` (`id`) ON DELETE CASCADE");
pstmt.executeUpdate();
pstmt.close();
pstmt =
conn.prepareStatement("ALTER TABLE `cloud`.`baremetal_pxe_devices` ADD CONSTRAINT `fk_external_pxe_devices_host_id` FOREIGN KEY (`host_id`) REFERENCES `host`(`id`) ON DELETE CASCADE");
pstmt.executeUpdate();
pstmt.close();
pstmt =
conn.prepareStatement("ALTER TABLE `cloud`.`baremetal_pxe_devices` ADD CONSTRAINT `fk_external_pxe_devices_physical_network_id` FOREIGN KEY (`physical_network_id`) REFERENCES `physical_network`(`id`) ON DELETE CASCADE");
pstmt.executeUpdate();
pstmt.close();
s_logger.debug("Added foreign keys for table baremetal_pxe_devices");
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to add foreign keys to baremetal_pxe_devices table", e);
}
}
private void addIndexForAlert(Connection conn) {
//First drop if it exists. (Due to patches shipped to customers some will have the index and some wont.)
List<String> indexList = new ArrayList<String>();
s_logger.debug("Dropping index i_alert__last_sent if it exists");
indexList.add("last_sent"); // in 4.1, we created this index that is not in convention.
indexList.add("i_alert__last_sent");
DbUpgradeUtils.dropKeysIfExist(conn, "alert", indexList, false);
//Now add index.
PreparedStatement pstmt = null;
try {
pstmt = conn.prepareStatement("ALTER TABLE `cloud`.`alert` ADD INDEX `i_alert__last_sent`(`last_sent`)");
pstmt.executeUpdate();
s_logger.debug("Added index i_alert__last_sent for table alert");
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to add index i_alert__last_sent to alert table for the column last_sent", e);
} finally {
try {
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void dropUploadTable(Connection conn) {
PreparedStatement pstmt0 = null;
PreparedStatement pstmt1 = null;
PreparedStatement pstmt2 = null;
PreparedStatement pstmt3 = null;
ResultSet rs0 = null;
ResultSet rs2 = null;
try {
// Read upload table - Templates
s_logger.debug("Populating template_store_ref table");
pstmt0 = conn.prepareStatement("SELECT url, created, type_id, host_id from upload where type=?");
pstmt0.setString(1, "TEMPLATE");
rs0 = pstmt0.executeQuery();
pstmt1 = conn.prepareStatement("UPDATE template_store_ref SET download_url=?, download_url_created=? where template_id=? and store_id=?");
//Update template_store_ref
while (rs0.next()) {
pstmt1.setString(1, rs0.getString("url"));
pstmt1.setDate(2, rs0.getDate("created"));
pstmt1.setLong(3, rs0.getLong("type_id"));
pstmt1.setLong(4, rs0.getLong("host_id"));
pstmt1.executeUpdate();
}
// Read upload table - Volumes
s_logger.debug("Populating volume store ref table");
pstmt2 = conn.prepareStatement("SELECT url, created, type_id, host_id, install_path from upload where type=?");
pstmt2.setString(1, "VOLUME");
rs2 = pstmt2.executeQuery();
pstmt3 =
conn.prepareStatement("INSERT IGNORE INTO volume_store_ref (volume_id, store_id, zone_id, created, state, download_url, download_url_created, install_path) VALUES (?,?,?,?,?,?,?,?)");
//insert into template_store_ref
while (rs2.next()) {
pstmt3.setLong(1, rs2.getLong("type_id"));
pstmt3.setLong(2, rs2.getLong("host_id"));
pstmt3.setLong(3, 1l);// ???
pstmt3.setDate(4, rs2.getDate("created"));
pstmt3.setString(5, "Ready");
pstmt3.setString(6, rs2.getString("url"));
pstmt3.setDate(7, rs2.getDate("created"));
pstmt3.setString(8, rs2.getString("install_path"));
pstmt3.executeUpdate();
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable add date into template/volume store ref from upload table.", e);
} finally {
try {
if (pstmt0 != null) {
pstmt0.close();
}
if (pstmt1 != null) {
pstmt1.close();
}
if (pstmt2 != null) {
pstmt2.close();
}
if (pstmt3 != null) {
pstmt3.close();
}
} catch (SQLException e) {
}
}
}
//KVM snapshot flag: only turn on if Customers is using snapshot;
private void setKVMSnapshotFlag(Connection conn) {
s_logger.debug("Verify and set the KVM snapshot flag if snapshot was used. ");
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
int numRows = 0;
pstmt = conn.prepareStatement("select count(*) from `cloud`.`snapshots` where hypervisor_type = 'KVM'");
rs = pstmt.executeQuery();
if (rs.next()) {
numRows = rs.getInt(1);
}
rs.close();
pstmt.close();
if (numRows > 0) {
//Add the configuration flag
pstmt = conn.prepareStatement("UPDATE `cloud`.`configuration` SET value = ? WHERE name = 'kvm.snapshot.enabled'");
pstmt.setString(1, "true");
pstmt.executeUpdate();
}
} catch (SQLException e) {
throw new CloudRuntimeException("Failed to read the snapshot table for KVM upgrade. ", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Done set KVM snapshot flag. ");
}
private void updatePrimaryStore(Connection conn) {
PreparedStatement sql = null;
PreparedStatement sql2 = null;
try {
sql = conn.prepareStatement("update storage_pool set storage_provider_name = ? , scope = ? where pool_type = 'Filesystem' or pool_type = 'LVM'");
sql.setString(1, DataStoreProvider.DEFAULT_PRIMARY);
sql.setString(2, "HOST");
sql.executeUpdate();
sql2 = conn.prepareStatement("update storage_pool set storage_provider_name = ? , scope = ? where pool_type != 'Filesystem' and pool_type != 'LVM'");
sql2.setString(1, DataStoreProvider.DEFAULT_PRIMARY);
sql2.setString(2, "CLUSTER");
sql2.executeUpdate();
} catch (SQLException e) {
throw new CloudRuntimeException("Failed to upgrade vm template data store uuid: " + e.toString());
} finally {
if (sql != null) {
try {
sql.close();
} catch (SQLException e) {
}
}
if (sql2 != null) {
try {
sql2.close();
} catch (SQLException e) {
}
}
}
}
//update the cluster_details table with default overcommit ratios.
private void updateOverCommitRatioClusterDetails(Connection conn) {
PreparedStatement pstmt = null;
PreparedStatement pstmt1 = null;
PreparedStatement pstmt2 = null;
PreparedStatement pstmt3 = null;
ResultSet rs1 = null;
ResultSet rscpu_global = null;
ResultSet rsmem_global = null;
try {
pstmt = conn.prepareStatement("select id, hypervisor_type from `cloud`.`cluster` WHERE removed IS NULL");
pstmt1 = conn.prepareStatement("INSERT INTO `cloud`.`cluster_details` (cluster_id, name, value) VALUES(?, 'cpuOvercommitRatio', ?)");
pstmt2 = conn.prepareStatement("INSERT INTO `cloud`.`cluster_details` (cluster_id, name, value) VALUES(?, 'memoryOvercommitRatio', ?)");
pstmt3 = conn.prepareStatement("select value from `cloud`.`configuration` where name=?");
pstmt3.setString(1, "cpu.overprovisioning.factor");
rscpu_global = pstmt3.executeQuery();
String global_cpu_overprovisioning_factor = "1";
if (rscpu_global.next())
global_cpu_overprovisioning_factor = rscpu_global.getString(1);
pstmt3.setString(1, "mem.overprovisioning.factor");
rsmem_global = pstmt3.executeQuery();
String global_mem_overprovisioning_factor = "1";
if (rsmem_global.next())
global_mem_overprovisioning_factor = rsmem_global.getString(1);
rs1 = pstmt.executeQuery();
while (rs1.next()) {
long id = rs1.getLong(1);
String hypervisor_type = rs1.getString(2);
if (HypervisorType.VMware.toString().equalsIgnoreCase(hypervisor_type)) {
pstmt1.setLong(1, id);
pstmt1.setString(2, global_cpu_overprovisioning_factor);
pstmt1.execute();
pstmt2.setLong(1, id);
pstmt2.setString(2, global_mem_overprovisioning_factor);
pstmt2.execute();
} else {
//update cluster_details table with the default overcommit ratios.
pstmt1.setLong(1, id);
pstmt1.setString(2, "1");
pstmt1.execute();
pstmt2.setLong(1, id);
pstmt2.setString(2, "1");
pstmt2.execute();
}
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to update cluster_details with default overcommit ratios.", e);
} finally {
try {
if (rs1 != null) {
rs1.close();
}
if (rsmem_global != null) {
rsmem_global.close();
}
if (rscpu_global != null) {
rscpu_global.close();
}
if (pstmt != null) {
pstmt.close();
}
if (pstmt2 != null) {
pstmt2.close();
}
if (pstmt3 != null) {
pstmt3.close();
}
} catch (SQLException e) {
}
}
}
@Override
public File[] getCleanupScripts() {
String script = Script.findScript("", "db/schema-410to420-cleanup.sql");
if (script == null) {
throw new CloudRuntimeException("Unable to find db/schema-410to420-cleanup.sql");
}
return new File[] {new File(script)};
}
private String getNewLabel(ResultSet rs, String oldParamValue) {
int separatorIndex;
String oldGuestLabel;
String newGuestLabel = oldParamValue;
try {
// No need to iterate because the global param setting applies to all physical networks irrespective of traffic type
if (rs.next()) {
oldGuestLabel = rs.getString("vmware_network_label");
// guestLabel is in format [[<VSWITCHNAME>],VLANID]
separatorIndex = oldGuestLabel.indexOf(",");
if (separatorIndex > -1) {
newGuestLabel += oldGuestLabel.substring(separatorIndex);
}
}
} catch (SQLException e) {
s_logger.error(new CloudRuntimeException("Failed to read vmware_network_label : " + e));
} finally {
try {
if (rs != null) {
rs.close();
}
} catch (SQLException e) {
}
}
return newGuestLabel;
}
private void upgradeVmwareLabels(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rsParams = null;
ResultSet rsLabel = null;
String newLabel;
String trafficType = null;
String trafficTypeVswitchParam;
String trafficTypeVswitchParamValue;
try {
// update the existing vmware traffic labels
pstmt =
conn.prepareStatement("select name,value from `cloud`.`configuration` where category='Hidden' and value is not NULL and name REGEXP 'vmware*.vswitch';");
rsParams = pstmt.executeQuery();
while (rsParams.next()) {
trafficTypeVswitchParam = rsParams.getString("name");
trafficTypeVswitchParamValue = rsParams.getString("value");
// When upgraded from 4.0 to 4.1 update physical network traffic label with trafficTypeVswitchParam
if (trafficTypeVswitchParam.equals("vmware.private.vswitch")) {
trafficType = "Management"; //TODO(sateesh): Ignore storage traffic, as required physical network already implemented, anything else tobe done?
} else if (trafficTypeVswitchParam.equals("vmware.public.vswitch")) {
trafficType = "Public";
} else if (trafficTypeVswitchParam.equals("vmware.guest.vswitch")) {
trafficType = "Guest";
}
pstmt =
conn.prepareStatement("select physical_network_id, traffic_type, vmware_network_label from physical_network_traffic_types where vmware_network_label is not NULL and traffic_type='" +
trafficType + "';");
rsLabel = pstmt.executeQuery();
newLabel = getNewLabel(rsLabel, trafficTypeVswitchParamValue);
pstmt =
conn.prepareStatement("update physical_network_traffic_types set vmware_network_label = " + newLabel + " where traffic_type = '" + trafficType +
"' and vmware_network_label is not NULL;");
s_logger.debug("Updating vmware label for " + trafficType + " traffic. Update SQL statement is " + pstmt);
pstmt.executeUpdate();
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to set vmware traffic labels ", e);
} finally {
try {
if (rsParams != null) {
rsParams.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void persistLegacyZones(Connection conn) {
List<Long> listOfLegacyZones = new ArrayList<Long>();
PreparedStatement pstmt = null;
PreparedStatement clustersQuery = null;
PreparedStatement clusterDetailsQuery = null;
ResultSet rs = null;
ResultSet clusters = null;
ResultSet clusterDetails = null;
ResultSet dcInfo = null;
Long vmwareDcId = 1L;
Long zoneId;
Long clusterId;
String clusterHypervisorType;
boolean legacyZone;
boolean ignoreZone;
Long count;
String dcOfPreviousCluster = null;
String dcOfCurrentCluster = null;
String[] tokens;
String url;
String user = "";
String password = "";
String vc = "";
String dcName = "";
String guid;
String key;
String value;
try {
pstmt = conn.prepareStatement("select id from `cloud`.`data_center` where removed is NULL");
rs = pstmt.executeQuery();
while (rs.next()) {
zoneId = rs.getLong("id");
clustersQuery = conn.prepareStatement("select id, hypervisor_type from `cloud`.`cluster` where removed is NULL AND data_center_id=?");
clustersQuery.setLong(1, zoneId);
legacyZone = false;
ignoreZone = true;
count = 0L;
// Legacy zone term is meant only for VMware
// Legacy zone is a zone with atleast 2 clusters & with multiple DCs or VCs
clusters = clustersQuery.executeQuery();
if (!clusters.next()) {
continue; // Ignore the zone without any clusters
} else {
dcOfPreviousCluster = null;
dcOfCurrentCluster = null;
do {
clusterHypervisorType = clusters.getString("hypervisor_type");
clusterId = clusters.getLong("id");
if (clusterHypervisorType.equalsIgnoreCase("VMware")) {
ignoreZone = false;
clusterDetailsQuery = conn.prepareStatement("select value from `cloud`.`cluster_details` where name='url' and cluster_id=?");
clusterDetailsQuery.setLong(1, clusterId);
clusterDetails = clusterDetailsQuery.executeQuery();
clusterDetails.next();
url = clusterDetails.getString("value");
tokens = url.split("/"); // url format - http://vcenter/dc/cluster
vc = tokens[2];
dcName = tokens[3];
dcOfPreviousCluster = dcOfCurrentCluster;
dcOfCurrentCluster = dcName + "@" + vc;
if (count > 0) {
if (!dcOfPreviousCluster.equalsIgnoreCase(dcOfCurrentCluster)) {
legacyZone = true;
s_logger.debug("Marking the zone " + zoneId + " as legacy zone.");
}
}
} else {
s_logger.debug("Ignoring zone " + zoneId + " with hypervisor type " + clusterHypervisorType);
break;
}
count++;
} while (clusters.next());
if (ignoreZone) {
continue; // Ignore the zone with hypervisors other than VMware
}
}
if (legacyZone) {
listOfLegacyZones.add(zoneId);
} else {
assert (clusterDetails != null) : "Couldn't retrieve details of cluster!";
s_logger.debug("Discovered non-legacy zone " + zoneId + ". Processing the zone to associate with VMware datacenter.");
clusterDetailsQuery = conn.prepareStatement("select name, value from `cloud`.`cluster_details` where cluster_id=?");
clusterDetailsQuery.setLong(1, clusterId);
clusterDetails = clusterDetailsQuery.executeQuery();
while (clusterDetails.next()) {
key = clusterDetails.getString(1);
value = clusterDetails.getString(2);
if (key.equalsIgnoreCase("username")) {
user = value;
} else if (key.equalsIgnoreCase("password")) {
password = value;
}
}
guid = dcName + "@" + vc;
pstmt =
conn.prepareStatement("INSERT INTO `cloud`.`vmware_data_center` (uuid, name, guid, vcenter_host, username, password) values(?, ?, ?, ?, ?, ?)");
pstmt.setString(1, UUID.randomUUID().toString());
pstmt.setString(2, dcName);
pstmt.setString(3, guid);
pstmt.setString(4, vc);
pstmt.setString(5, user);
pstmt.setString(6, password);
pstmt.executeUpdate();
pstmt = conn.prepareStatement("SELECT id FROM `cloud`.`vmware_data_center` where guid=?");
pstmt.setString(1, guid);
dcInfo = pstmt.executeQuery();
if (dcInfo.next()) {
vmwareDcId = dcInfo.getLong("id");
}
pstmt = conn.prepareStatement("INSERT INTO `cloud`.`vmware_data_center_zone_map` (zone_id, vmware_data_center_id) values(?, ?)");
pstmt.setLong(1, zoneId);
pstmt.setLong(2, vmwareDcId);
pstmt.executeUpdate();
}
}
updateLegacyZones(conn, listOfLegacyZones);
} catch (SQLException e) {
String msg = "Unable to discover legacy zones." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
if (dcInfo != null) {
dcInfo.close();
}
if (clusters != null) {
clusters.close();
}
if (clusterDetails != null) {
clusterDetails.close();
}
if (clustersQuery != null) {
clustersQuery.close();
}
if (clusterDetailsQuery != null) {
clusterDetailsQuery.close();
}
} catch (SQLException e) {
}
}
}
private void updateLegacyZones(Connection conn, List<Long> zones) {
PreparedStatement legacyZonesQuery = null;
//Insert legacy zones into table for legacy zones.
try {
legacyZonesQuery = conn.prepareStatement("INSERT INTO `cloud`.`legacy_zones` (zone_id) VALUES (?)");
for (Long zoneId : zones) {
legacyZonesQuery.setLong(1, zoneId);
legacyZonesQuery.executeUpdate();
s_logger.debug("Inserted zone " + zoneId + " into cloud.legacyzones table");
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable add zones to cloud.legacyzones table.", e);
} finally {
try {
if (legacyZonesQuery != null) {
legacyZonesQuery.close();
}
} catch (SQLException e) {
}
}
}
private void createPlaceHolderNics(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt =
conn.prepareStatement("SELECT network_id, gateway, ip4_address FROM `cloud`.`nics` WHERE reserver_name IN ('DirectNetworkGuru','DirectPodBasedNetworkGuru') and vm_type='DomainRouter' AND removed IS null");
rs = pstmt.executeQuery();
while (rs.next()) {
Long networkId = rs.getLong(1);
String gateway = rs.getString(2);
String ip = rs.getString(3);
String uuid = UUID.randomUUID().toString();
//Insert placeholder nic for each Domain router nic in Shared network
pstmt =
conn.prepareStatement("INSERT INTO `cloud`.`nics` (uuid, ip4_address, gateway, network_id, state, strategy, vm_type, default_nic, created) VALUES (?, ?, ?, ?, 'Reserved', 'PlaceHolder', 'DomainRouter', 0, now())");
pstmt.setString(1, uuid);
pstmt.setString(2, ip);
pstmt.setString(3, gateway);
pstmt.setLong(4, networkId);
pstmt.executeUpdate();
s_logger.debug("Created placeholder nic for the ipAddress " + ip + " and network " + networkId);
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to create placeholder nics", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void updateRemoteAccessVpn(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = conn.prepareStatement("SELECT vpn_server_addr_id FROM `cloud`.`remote_access_vpn`");
rs = pstmt.executeQuery();
long id = 1;
while (rs.next()) {
String uuid = UUID.randomUUID().toString();
Long ipId = rs.getLong(1);
pstmt = conn.prepareStatement("UPDATE `cloud`.`remote_access_vpn` set uuid=?, id=? where vpn_server_addr_id=?");
pstmt.setString(1, uuid);
pstmt.setLong(2, id);
pstmt.setLong(3, ipId);
pstmt.executeUpdate();
id++;
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to update id/uuid of remote_access_vpn table", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void addEgressFwRulesForSRXGuestNw(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
ResultSet rsId = null;
ResultSet rsNw = null;
try {
pstmt = conn.prepareStatement("select network_id FROM `cloud`.`ntwk_service_map` where service='Firewall' and provider='JuniperSRX' ");
rs = pstmt.executeQuery();
while (rs.next()) {
long netId = rs.getLong(1);
//checking for Isolated OR Virtual
pstmt =
conn.prepareStatement("select account_id, domain_id FROM `cloud`.`networks` where (guest_type='Isolated' OR guest_type='Virtual') and traffic_type='Guest' and vpc_id is NULL and (state='implemented' OR state='Shutdown') and id=? ");
pstmt.setLong(1, netId);
s_logger.debug("Getting account_id, domain_id from networks table: " + pstmt);
rsNw = pstmt.executeQuery();
if (rsNw.next()) {
long accountId = rsNw.getLong(1);
long domainId = rsNw.getLong(2);
//Add new rule for the existing networks
s_logger.debug("Adding default egress firewall rule for network " + netId);
pstmt =
conn.prepareStatement("INSERT INTO firewall_rules (uuid, state, protocol, purpose, account_id, domain_id, network_id, xid, created, traffic_type) VALUES (?, 'Active', 'all', 'Firewall', ?, ?, ?, ?, now(), 'Egress')");
pstmt.setString(1, UUID.randomUUID().toString());
pstmt.setLong(2, accountId);
pstmt.setLong(3, domainId);
pstmt.setLong(4, netId);
pstmt.setString(5, UUID.randomUUID().toString());
s_logger.debug("Inserting default egress firewall rule " + pstmt);
pstmt.executeUpdate();
pstmt = conn.prepareStatement("select id from firewall_rules where protocol='all' and network_id=?");
pstmt.setLong(1, netId);
rsId = pstmt.executeQuery();
long firewallRuleId;
if (rsId.next()) {
firewallRuleId = rsId.getLong(1);
pstmt = conn.prepareStatement("insert into firewall_rules_cidrs (firewall_rule_id,source_cidr) values (?, '0.0.0.0/0')");
pstmt.setLong(1, firewallRuleId);
s_logger.debug("Inserting rule for cidr 0.0.0.0/0 for the new Firewall rule id=" + firewallRuleId + " with statement " + pstmt);
pstmt.executeUpdate();
}
}
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to set egress firewall rules ", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void upgradeEIPNetworkOfferings(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = conn.prepareStatement("select id, elastic_ip_service from `cloud`.`network_offerings` where traffic_type='Guest'");
rs = pstmt.executeQuery();
while (rs.next()) {
long id = rs.getLong(1);
// check if elastic IP service is enabled for network offering
if (rs.getLong(2) != 0) {
//update network offering with eip_associate_public_ip set to true
pstmt = conn.prepareStatement("UPDATE `cloud`.`network_offerings` set eip_associate_public_ip=? where id=?");
pstmt.setBoolean(1, true);
pstmt.setLong(2, id);
pstmt.executeUpdate();
}
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to set elastic_ip_service for network offerings with EIP service enabled.", e);
}
}
private void updateNetworkACLs(Connection conn) {
//Fetch all VPC Tiers
//For each tier create a network ACL and move all the acl_items to network_acl_item table
// If there are no acl_items for a tier, associate it with default ACL
s_logger.debug("Updating network ACLs");
PreparedStatement pstmt = null;
PreparedStatement pstmtDelete = null;
ResultSet rs = null;
ResultSet rsAcls = null;
ResultSet rsCidr = null;
//1,2 are default acl Ids, start acl Ids from 3
long nextAclId = 3;
try {
//Get all VPC tiers
pstmt = conn.prepareStatement("SELECT id, vpc_id, uuid FROM `cloud`.`networks` where vpc_id is not null and removed is null");
rs = pstmt.executeQuery();
while (rs.next()) {
Long networkId = rs.getLong(1);
s_logger.debug("Updating network ACLs for network: " + networkId);
Long vpcId = rs.getLong(2);
String tierUuid = rs.getString(3);
pstmt =
conn.prepareStatement("SELECT id, uuid, start_port, end_port, state, protocol, icmp_code, icmp_type, created, traffic_type FROM `cloud`.`firewall_rules` where network_id = ? and purpose = 'NetworkACL'");
pstmt.setLong(1, networkId);
rsAcls = pstmt.executeQuery();
boolean hasAcls = false;
Long aclId = null;
int number = 1;
while (rsAcls.next()) {
if (!hasAcls) {
hasAcls = true;
aclId = nextAclId++;
//create ACL for the tier
s_logger.debug("Creating network ACL for tier: " + tierUuid);
pstmt = conn.prepareStatement("INSERT INTO `cloud`.`network_acl` (id, uuid, vpc_id, description, name) values (?, UUID(), ? , ?, ?)");
pstmt.setLong(1, aclId);
pstmt.setLong(2, vpcId);
pstmt.setString(3, "ACL for tier " + tierUuid);
pstmt.setString(4, "tier_" + tierUuid);
pstmt.executeUpdate();
}
Long fwRuleId = rsAcls.getLong(1);
String cidr = null;
//get cidr from firewall_rules_cidrs
pstmt = conn.prepareStatement("SELECT id, source_cidr FROM `cloud`.`firewall_rules_cidrs` where firewall_rule_id = ?");
pstmt.setLong(1, fwRuleId);
rsCidr = pstmt.executeQuery();
while (rsCidr.next()) {
Long cidrId = rsCidr.getLong(1);
String sourceCidr = rsCidr.getString(2);
if (cidr == null) {
cidr = sourceCidr;
} else {
cidr += "," + sourceCidr;
}
//Delete cidr entry
pstmtDelete = conn.prepareStatement("DELETE FROM `cloud`.`firewall_rules_cidrs` where id = ?");
pstmtDelete.setLong(1, cidrId);
pstmtDelete.executeUpdate();
}
String aclItemUuid = rsAcls.getString(2);
//Move acl to network_acl_item table
s_logger.debug("Moving firewall rule: " + aclItemUuid);
pstmt =
conn.prepareStatement("INSERT INTO `cloud`.`network_acl_item` (uuid, acl_id, start_port, end_port, state, protocol, icmp_code, icmp_type, created, traffic_type, cidr, number, action) values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? )");
//uuid
pstmt.setString(1, aclItemUuid);
//aclId
pstmt.setLong(2, aclId);
//Start port
Integer startPort = rsAcls.getInt(3);
if (rsAcls.wasNull()) {
pstmt.setNull(3, Types.INTEGER);
} else {
pstmt.setLong(3, startPort);
}
//End port
Integer endPort = rsAcls.getInt(4);
if (rsAcls.wasNull()) {
pstmt.setNull(4, Types.INTEGER);
} else {
pstmt.setLong(4, endPort);
}
//State
String state = rsAcls.getString(5);
pstmt.setString(5, state);
//protocol
String protocol = rsAcls.getString(6);
pstmt.setString(6, protocol);
//icmp_code
Integer icmpCode = rsAcls.getInt(7);
if (rsAcls.wasNull()) {
pstmt.setNull(7, Types.INTEGER);
} else {
pstmt.setLong(7, icmpCode);
}
//icmp_type
Integer icmpType = rsAcls.getInt(8);
if (rsAcls.wasNull()) {
pstmt.setNull(8, Types.INTEGER);
} else {
pstmt.setLong(8, icmpType);
}
//created
Date created = rsAcls.getDate(9);
pstmt.setDate(9, created);
//traffic type
String trafficType = rsAcls.getString(10);
pstmt.setString(10, trafficType);
//cidr
pstmt.setString(11, cidr);
//number
pstmt.setInt(12, number++);
//action
pstmt.setString(13, "Allow");
pstmt.executeUpdate();
//Delete firewall rule
pstmtDelete = conn.prepareStatement("DELETE FROM `cloud`.`firewall_rules` where id = ?");
pstmtDelete.setLong(1, fwRuleId);
pstmtDelete.executeUpdate();
}
if (!hasAcls) {
//no network ACls for this network.
// Assign default Deny ACL
aclId = NetworkACL.DEFAULT_DENY;
}
//Assign acl to network
pstmt = conn.prepareStatement("UPDATE `cloud`.`networks` set network_acl_id=? where id=?");
pstmt.setLong(1, aclId);
pstmt.setLong(2, networkId);
pstmt.executeUpdate();
}
s_logger.debug("Done updating network ACLs ");
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to move network acls from firewall rules table to network_acl_item table", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (rsAcls != null) {
rsAcls.close();
}
if (rsCidr != null) {
rsCidr.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void updateGlobalDeploymentPlanner(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = conn.prepareStatement("select value from `cloud`.`configuration` where name = 'vm.allocation.algorithm'");
rs = pstmt.executeQuery();
while (rs.next()) {
String globalValue = rs.getString(1);
String plannerName = "FirstFitPlanner";
if (globalValue != null) {
if (globalValue.equals(DeploymentPlanner.AllocationAlgorithm.random.toString())) {
plannerName = "FirstFitPlanner";
} else if (globalValue.equals(DeploymentPlanner.AllocationAlgorithm.firstfit.toString())) {
plannerName = "FirstFitPlanner";
} else if (globalValue.equals(DeploymentPlanner.AllocationAlgorithm.userconcentratedpod_firstfit.toString())) {
plannerName = "UserConcentratedPodPlanner";
} else if (globalValue.equals(DeploymentPlanner.AllocationAlgorithm.userconcentratedpod_random.toString())) {
plannerName = "UserConcentratedPodPlanner";
} else if (globalValue.equals(DeploymentPlanner.AllocationAlgorithm.userdispersing.toString())) {
plannerName = "UserDispersingPlanner";
}
}
// update vm.deployment.planner global config
pstmt = conn.prepareStatement("UPDATE `cloud`.`configuration` set value=? where name = 'vm.deployment.planner'");
pstmt.setString(1, plannerName);
pstmt.executeUpdate();
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to set vm.deployment.planner global config", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void upgradeDefaultVpcOffering(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt =
conn.prepareStatement("select distinct map.vpc_offering_id from `cloud`.`vpc_offering_service_map` map, `cloud`.`vpc_offerings` off where off.id=map.vpc_offering_id AND service='Lb'");
rs = pstmt.executeQuery();
while (rs.next()) {
long id = rs.getLong(1);
//Add internal LB vm as a supported provider for the load balancer service
pstmt = conn.prepareStatement("INSERT INTO `cloud`.`vpc_offering_service_map` (vpc_offering_id, service, provider) VALUES (?,?,?)");
pstmt.setLong(1, id);
pstmt.setString(2, "Lb");
pstmt.setString(3, "InternalLbVm");
pstmt.executeUpdate();
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable update the default VPC offering with the internal lb service", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void upgradePhysicalNtwksWithInternalLbProvider(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = conn.prepareStatement("SELECT id FROM `cloud`.`physical_network` where removed is null");
rs = pstmt.executeQuery();
while (rs.next()) {
long pNtwkId = rs.getLong(1);
String uuid = UUID.randomUUID().toString();
//Add internal LB VM to the list of physical network service providers
pstmt =
conn.prepareStatement("INSERT INTO `cloud`.`physical_network_service_providers` "
+ "(uuid, physical_network_id, provider_name, state, load_balance_service_provided, destination_physical_network_id)"
+ " VALUES (?, ?, 'InternalLbVm', 'Enabled', 1, 0)");
pstmt.setString(1, uuid);
pstmt.setLong(2, pNtwkId);
pstmt.executeUpdate();
//Add internal lb vm to the list of physical network elements
PreparedStatement pstmt1 =
conn.prepareStatement("SELECT id FROM `cloud`.`physical_network_service_providers`" + " WHERE physical_network_id=? AND provider_name='InternalLbVm'");
pstmt1.setLong(1, pNtwkId);
ResultSet rs1 = pstmt1.executeQuery();
while (rs1.next()) {
long providerId = rs1.getLong(1);
uuid = UUID.randomUUID().toString();
pstmt1 = conn.prepareStatement("INSERT INTO `cloud`.`virtual_router_providers` (nsp_id, uuid, type, enabled) VALUES (?, ?, 'InternalLbVm', 1)");
pstmt1.setLong(1, providerId);
pstmt1.setString(2, uuid);
pstmt1.executeUpdate();
}
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to update existing physical networks with internal lb provider", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void addHostDetailsIndex(Connection conn) {
s_logger.debug("Checking if host_details index exists, if not we will add it");
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = conn.prepareStatement("SHOW INDEX FROM `cloud`.`host_details` where KEY_NAME = 'fk_host_details__host_id'");
rs = pstmt.executeQuery();
if (rs.next()) {
s_logger.debug("Index already exists on host_details - not adding new one");
} else {
// add the index
PreparedStatement pstmtUpdate = conn.prepareStatement("ALTER IGNORE TABLE `cloud`.`host_details` ADD INDEX `fk_host_details__host_id` (`host_id`)");
pstmtUpdate.executeUpdate();
s_logger.debug("Index did not exist on host_details - added new one");
pstmtUpdate.close();
}
} catch (SQLException e) {
throw new CloudRuntimeException("Failed to check/update the host_details index ", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void updateNetworksForPrivateGateways(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
//1) get all non removed gateways
pstmt = conn.prepareStatement("SELECT network_id, vpc_id FROM `cloud`.`vpc_gateways` WHERE type='Private' AND removed IS null");
rs = pstmt.executeQuery();
while (rs.next()) {
Long networkId = rs.getLong(1);
Long vpcId = rs.getLong(2);
//2) Update networks with vpc_id if its set to NULL
pstmt = conn.prepareStatement("UPDATE `cloud`.`networks` set vpc_id=? where id=? and vpc_id is NULL and removed is NULL");
pstmt.setLong(1, vpcId);
pstmt.setLong(2, networkId);
pstmt.executeUpdate();
}
} catch (SQLException e) {
throw new CloudRuntimeException("Failed to update private networks with VPC id.", e);
}
}
private void removeFirewallServiceFromSharedNetworkOfferingWithSGService(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = conn.prepareStatement("select id from `cloud`.`network_offerings` where unique_name='DefaultSharedNetworkOfferingWithSGService'");
rs = pstmt.executeQuery();
while (rs.next()) {
long id = rs.getLong(1);
// remove Firewall service for SG shared network offering
pstmt = conn.prepareStatement("DELETE from `cloud`.`ntwk_offering_service_map` where network_offering_id=? and service='Firewall'");
pstmt.setLong(1, id);
pstmt.executeUpdate();
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to remove Firewall service for SG shared network offering.", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void fix22xKVMSnapshots(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
s_logger.debug("Updating KVM snapshots");
try {
pstmt =
conn.prepareStatement("select id, backup_snap_id from `cloud`.`snapshots` where hypervisor_type='KVM' and removed is null and backup_snap_id is not null");
rs = pstmt.executeQuery();
while (rs.next()) {
long id = rs.getLong(1);
String backUpPath = rs.getString(2);
// Update Backup Path. Remove anything before /snapshots/
// e.g 22x Path /mnt/0f14da63-7033-3ca5-bdbe-fa62f4e2f38a/snapshots/1/2/6/i-2-6-VM_ROOT-6_20121219072022
// Above path should change to /snapshots/1/2/6/i-2-6-VM_ROOT-6_20121219072022
int index = backUpPath.indexOf("snapshots" + File.separator);
if (index > 1) {
String correctedPath = backUpPath.substring(index);
s_logger.debug("Updating Snapshot with id: " + id + " original backup path: " + backUpPath + " updated backup path: " + correctedPath);
pstmt = conn.prepareStatement("UPDATE `cloud`.`snapshots` set backup_snap_id=? where id = ?");
pstmt.setString(1, correctedPath);
pstmt.setLong(2, id);
pstmt.executeUpdate();
}
}
s_logger.debug("Done updating KVM snapshots");
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to update backup id for KVM snapshots", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
// Corrects upgrade for deployment with F5 and SRX devices (pre 3.0) to network offering &
// network service provider paradigm
private void correctExternalNetworkDevicesSetup(Connection conn) {
PreparedStatement zoneSearchStmt = null, pNetworkStmt = null, f5DevicesStmt = null, srxDevicesStmt = null;
ResultSet zoneResults = null, pNetworksResults = null, f5DevicesResult = null, srxDevicesResult = null;
try {
zoneSearchStmt = conn.prepareStatement("SELECT id, networktype FROM `cloud`.`data_center`");
zoneResults = zoneSearchStmt.executeQuery();
while (zoneResults.next()) {
long zoneId = zoneResults.getLong(1);
String networkType = zoneResults.getString(2);
if (!com.cloud.dc.DataCenter.NetworkType.Advanced.toString().equalsIgnoreCase(networkType)) {
continue;
}
pNetworkStmt = conn.prepareStatement("SELECT id FROM `cloud`.`physical_network` where data_center_id=?");
pNetworkStmt.setLong(1, zoneId);
pNetworksResults = pNetworkStmt.executeQuery();
while (pNetworksResults.next()) {
long physicalNetworkId = pNetworksResults.getLong(1);
PreparedStatement fetchF5NspStmt =
conn.prepareStatement("SELECT id from `cloud`.`physical_network_service_providers` where physical_network_id=" + physicalNetworkId +
" and provider_name = 'F5BigIp'");
ResultSet rsF5NSP = fetchF5NspStmt.executeQuery();
boolean hasF5Nsp = rsF5NSP.next();
fetchF5NspStmt.close();
// if there is no 'F5BigIP' physical network service provider added into physical network then
// add 'F5BigIP' as network service provider and add the entry in 'external_load_balancer_devices'
if (!hasF5Nsp) {
f5DevicesStmt = conn.prepareStatement("SELECT id FROM host WHERE data_center_id=? AND type = 'ExternalLoadBalancer' AND removed IS NULL");
f5DevicesStmt.setLong(1, zoneId);
f5DevicesResult = f5DevicesStmt.executeQuery();
// add F5BigIP provider and provider instance to physical network if there are any external load
// balancers added in the zone
while (f5DevicesResult.next()) {
long f5HostId = f5DevicesResult.getLong(1);
;
addF5ServiceProvider(conn, physicalNetworkId, zoneId);
addF5LoadBalancer(conn, f5HostId, physicalNetworkId);
}
}
PreparedStatement fetchSRXNspStmt =
conn.prepareStatement("SELECT id from `cloud`.`physical_network_service_providers` where physical_network_id=" + physicalNetworkId +
" and provider_name = 'JuniperSRX'");
ResultSet rsSRXNSP = fetchSRXNspStmt.executeQuery();
boolean hasSrxNsp = rsSRXNSP.next();
fetchSRXNspStmt.close();
// if there is no 'JuniperSRX' physical network service provider added into physical network then
// add 'JuniperSRX' as network service provider and add the entry in 'external_firewall_devices'
if (!hasSrxNsp) {
srxDevicesStmt = conn.prepareStatement("SELECT id FROM host WHERE data_center_id=? AND type = 'ExternalFirewall' AND removed IS NULL");
srxDevicesStmt.setLong(1, zoneId);
srxDevicesResult = srxDevicesStmt.executeQuery();
// add JuniperSRX provider and provider instance to physical network if there are any external
// firewall instances added in to the zone
while (srxDevicesResult.next()) {
long srxHostId = srxDevicesResult.getLong(1);
// add SRX provider and provider instance to physical network
addSrxServiceProvider(conn, physicalNetworkId, zoneId);
addSrxFirewall(conn, srxHostId, physicalNetworkId);
}
}
}
}
// not the network service provider has been provisioned in to physical network, mark all guest network
// to be using network offering 'Isolated with external providers'
fixZoneUsingExternalDevices(conn);
if (zoneResults != null) {
try {
zoneResults.close();
} catch (SQLException e) {
}
}
if (zoneSearchStmt != null) {
try {
zoneSearchStmt.close();
} catch (SQLException e) {
}
}
} catch (SQLException e) {
throw new CloudRuntimeException("Exception while adding PhysicalNetworks", e);
} finally {
}
}
private void addF5LoadBalancer(Connection conn, long hostId, long physicalNetworkId) {
PreparedStatement pstmtUpdate = null;
try {
s_logger.debug("Adding F5 Big IP load balancer with host id " + hostId + " in to physical network" + physicalNetworkId);
String insertF5 =
"INSERT INTO `cloud`.`external_load_balancer_devices` (physical_network_id, host_id, provider_name, "
+ "device_name, capacity, is_dedicated, device_state, allocation_state, is_managed, uuid) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
pstmtUpdate = conn.prepareStatement(insertF5);
pstmtUpdate.setLong(1, physicalNetworkId);
pstmtUpdate.setLong(2, hostId);
pstmtUpdate.setString(3, "F5BigIp");
pstmtUpdate.setString(4, "F5BigIpLoadBalancer");
pstmtUpdate.setLong(5, 0);
pstmtUpdate.setBoolean(6, false);
pstmtUpdate.setString(7, "Enabled");
pstmtUpdate.setString(8, "Shared");
pstmtUpdate.setBoolean(9, false);
pstmtUpdate.setString(10, UUID.randomUUID().toString());
pstmtUpdate.executeUpdate();
} catch (SQLException e) {
throw new CloudRuntimeException("Exception while adding F5 load balancer device", e);
} finally {
if (pstmtUpdate != null) {
try {
pstmtUpdate.close();
} catch (SQLException e) {
}
}
}
}
private void addSrxFirewall(Connection conn, long hostId, long physicalNetworkId) {
PreparedStatement pstmtUpdate = null;
try {
s_logger.debug("Adding SRX firewall device with host id " + hostId + " in to physical network" + physicalNetworkId);
String insertSrx =
"INSERT INTO `cloud`.`external_firewall_devices` (physical_network_id, host_id, provider_name, "
+ "device_name, capacity, is_dedicated, device_state, allocation_state, uuid) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?)";
pstmtUpdate = conn.prepareStatement(insertSrx);
pstmtUpdate.setLong(1, physicalNetworkId);
pstmtUpdate.setLong(2, hostId);
pstmtUpdate.setString(3, "JuniperSRX");
pstmtUpdate.setString(4, "JuniperSRXFirewall");
pstmtUpdate.setLong(5, 0);
pstmtUpdate.setBoolean(6, false);
pstmtUpdate.setString(7, "Enabled");
pstmtUpdate.setString(8, "Shared");
pstmtUpdate.setString(9, UUID.randomUUID().toString());
pstmtUpdate.executeUpdate();
} catch (SQLException e) {
throw new CloudRuntimeException("Exception while adding SRX firewall device ", e);
} finally {
if (pstmtUpdate != null) {
try {
pstmtUpdate.close();
} catch (SQLException e) {
}
}
}
}
private void addF5ServiceProvider(Connection conn, long physicalNetworkId, long zoneId) {
PreparedStatement pstmtUpdate = null;
try {
// add physical network service provider - F5BigIp
s_logger.debug("Adding PhysicalNetworkServiceProvider F5BigIp" + " in to physical network" + physicalNetworkId);
String insertPNSP =
"INSERT INTO `cloud`.`physical_network_service_providers` (`uuid`, `physical_network_id` , `provider_name`, `state` ,"
+ "`destination_physical_network_id`, `vpn_service_provided`, `dhcp_service_provided`, `dns_service_provided`, `gateway_service_provided`,"
+ "`firewall_service_provided`, `source_nat_service_provided`, `load_balance_service_provided`, `static_nat_service_provided`,"
+ "`port_forwarding_service_provided`, `user_data_service_provided`, `security_group_service_provided`) VALUES (?,?,?,?,0,0,0,0,0,0,0,1,0,0,0,0)";
pstmtUpdate = conn.prepareStatement(insertPNSP);
pstmtUpdate.setString(1, UUID.randomUUID().toString());
pstmtUpdate.setLong(2, physicalNetworkId);
pstmtUpdate.setString(3, "F5BigIp");
pstmtUpdate.setString(4, "Enabled");
pstmtUpdate.executeUpdate();
} catch (SQLException e) {
throw new CloudRuntimeException("Exception while adding PhysicalNetworkServiceProvider F5BigIp", e);
} finally {
if (pstmtUpdate != null) {
try {
pstmtUpdate.close();
} catch (SQLException e) {
}
}
}
}
private void addSrxServiceProvider(Connection conn, long physicalNetworkId, long zoneId) {
PreparedStatement pstmtUpdate = null;
try {
// add physical network service provider - JuniperSRX
s_logger.debug("Adding PhysicalNetworkServiceProvider JuniperSRX");
String insertPNSP =
"INSERT INTO `cloud`.`physical_network_service_providers` (`uuid`, `physical_network_id` , `provider_name`, `state` ,"
+ "`destination_physical_network_id`, `vpn_service_provided`, `dhcp_service_provided`, `dns_service_provided`, `gateway_service_provided`,"
+ "`firewall_service_provided`, `source_nat_service_provided`, `load_balance_service_provided`, `static_nat_service_provided`,"
+ "`port_forwarding_service_provided`, `user_data_service_provided`, `security_group_service_provided`) VALUES (?,?,?,?,0,0,0,0,1,1,1,0,1,1,0,0)";
pstmtUpdate = conn.prepareStatement(insertPNSP);
pstmtUpdate.setString(1, UUID.randomUUID().toString());
pstmtUpdate.setLong(2, physicalNetworkId);
pstmtUpdate.setString(3, "JuniperSRX");
pstmtUpdate.setString(4, "Enabled");
pstmtUpdate.executeUpdate();
} catch (SQLException e) {
throw new CloudRuntimeException("Exception while adding PhysicalNetworkServiceProvider JuniperSRX", e);
} finally {
if (pstmtUpdate != null) {
try {
pstmtUpdate.close();
} catch (SQLException e) {
}
}
}
}
// This method does two things
//
// 1) ensure that networks using external load balancer/firewall in deployments prior to release 3.0
// has entry in network_external_lb_device_map and network_external_firewall_device_map
//
// 2) Some keys of host details for F5 and SRX devices were stored in Camel Case in 2.x releases. From 3.0
// they are made in lowercase. On upgrade change the host details name to lower case
private void fixZoneUsingExternalDevices(Connection conn) {
//Get zones to upgrade
List<Long> zoneIds = new ArrayList<Long>();
PreparedStatement pstmt = null;
PreparedStatement pstmtUpdate = null;
ResultSet rs = null;
long networkOfferingId, networkId;
long f5DeviceId, f5HostId;
long srxDevivceId, srxHostId;
try {
pstmt =
conn.prepareStatement("select id from `cloud`.`data_center` where lb_provider='F5BigIp' or firewall_provider='JuniperSRX' or gateway_provider='JuniperSRX'");
rs = pstmt.executeQuery();
while (rs.next()) {
zoneIds.add(rs.getLong(1));
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to create network to LB & firewall device mapping for networks that use them", e);
}
if (zoneIds.size() == 0) {
return; // no zones using F5 and SRX devices so return
}
// find the default network offering created for external devices during upgrade from 2.2.14
try {
pstmt = conn.prepareStatement("select id from `cloud`.`network_offerings` where unique_name='Isolated with external providers' ");
rs = pstmt.executeQuery();
if (rs.first()) {
networkOfferingId = rs.getLong(1);
} else {
throw new CloudRuntimeException("Cannot upgrade as there is no 'Isolated with external providers' network offering crearted .");
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to create network to LB & firewalla device mapping for networks that use them", e);
}
for (Long zoneId : zoneIds) {
try {
// find the F5 device id in the zone
pstmt = conn.prepareStatement("SELECT id FROM host WHERE data_center_id=? AND type = 'ExternalLoadBalancer' AND removed IS NULL");
pstmt.setLong(1, zoneId);
rs = pstmt.executeQuery();
if (rs.first()) {
f5HostId = rs.getLong(1);
} else {
throw new CloudRuntimeException("Cannot upgrade as there is no F5 load balancer device found in data center " + zoneId);
}
pstmt = conn.prepareStatement("SELECT id FROM external_load_balancer_devices WHERE host_id=?");
pstmt.setLong(1, f5HostId);
rs = pstmt.executeQuery();
if (rs.first()) {
f5DeviceId = rs.getLong(1);
} else {
throw new CloudRuntimeException("Cannot upgrade as there is no F5 load balancer device with host ID " + f5HostId +
" found in external_load_balancer_device");
}
// find the SRX device id in the zone
pstmt = conn.prepareStatement("SELECT id FROM host WHERE data_center_id=? AND type = 'ExternalFirewall' AND removed IS NULL");
pstmt.setLong(1, zoneId);
rs = pstmt.executeQuery();
if (rs.first()) {
srxHostId = rs.getLong(1);
} else {
throw new CloudRuntimeException("Cannot upgrade as there is no SRX firewall device found in data center " + zoneId);
}
pstmt = conn.prepareStatement("SELECT id FROM external_firewall_devices WHERE host_id=?");
pstmt.setLong(1, srxHostId);
rs = pstmt.executeQuery();
if (rs.first()) {
srxDevivceId = rs.getLong(1);
} else {
throw new CloudRuntimeException("Cannot upgrade as there is no SRX firewall device found with host ID " + srxHostId +
" found in external_firewall_devices");
}
// check if network any uses F5 or SRX devices in the zone
pstmt =
conn.prepareStatement("select id from `cloud`.`networks` where guest_type='Virtual' and data_center_id=? and network_offering_id=? and removed IS NULL");
pstmt.setLong(1, zoneId);
pstmt.setLong(2, networkOfferingId);
rs = pstmt.executeQuery();
while (rs.next()) {
// get the network Id
networkId = rs.getLong(1);
// add mapping for the network in network_external_lb_device_map
String insertLbMapping =
"INSERT INTO `cloud`.`network_external_lb_device_map` (uuid, network_id, external_load_balancer_device_id, created) VALUES ( ?, ?, ?, now())";
pstmtUpdate = conn.prepareStatement(insertLbMapping);
pstmtUpdate.setString(1, UUID.randomUUID().toString());
pstmtUpdate.setLong(2, networkId);
pstmtUpdate.setLong(3, f5DeviceId);
pstmtUpdate.executeUpdate();
s_logger.debug("Successfully added entry in network_external_lb_device_map for network " + networkId + " and F5 device ID " + f5DeviceId);
// add mapping for the network in network_external_firewall_device_map
String insertFwMapping =
"INSERT INTO `cloud`.`network_external_firewall_device_map` (uuid, network_id, external_firewall_device_id, created) VALUES ( ?, ?, ?, now())";
pstmtUpdate = conn.prepareStatement(insertFwMapping);
pstmtUpdate.setString(1, UUID.randomUUID().toString());
pstmtUpdate.setLong(2, networkId);
pstmtUpdate.setLong(3, srxDevivceId);
pstmtUpdate.executeUpdate();
s_logger.debug("Successfully added entry in network_external_firewall_device_map for network " + networkId + " and SRX device ID " + srxDevivceId);
}
// update host details for F5 and SRX devices
s_logger.debug("Updating the host details for F5 and SRX devices");
pstmt = conn.prepareStatement("SELECT host_id, name FROM `cloud`.`host_details` WHERE host_id=? OR host_id=?");
pstmt.setLong(1, f5HostId);
pstmt.setLong(2, srxHostId);
rs = pstmt.executeQuery();
while (rs.next()) {
long hostId = rs.getLong(1);
String camlCaseName = rs.getString(2);
if (!(camlCaseName.equalsIgnoreCase("numRetries") || camlCaseName.equalsIgnoreCase("publicZone") || camlCaseName.equalsIgnoreCase("privateZone") ||
camlCaseName.equalsIgnoreCase("publicInterface") || camlCaseName.equalsIgnoreCase("privateInterface") || camlCaseName.equalsIgnoreCase("usageInterface"))) {
continue;
}
String lowerCaseName = camlCaseName.toLowerCase();
pstmt = conn.prepareStatement("update `cloud`.`host_details` set name=? where host_id=? AND name=?");
pstmt.setString(1, lowerCaseName);
pstmt.setLong(2, hostId);
pstmt.setString(3, camlCaseName);
pstmt.executeUpdate();
}
s_logger.debug("Successfully updated host details for F5 and SRX devices");
} catch (SQLException e) {
throw new CloudRuntimeException("Unable create a mapping for the networks in network_external_lb_device_map and network_external_firewall_device_map", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
s_logger.info("Successfully upgraded network using F5 and SRX devices to have a entry in the network_external_lb_device_map and network_external_firewall_device_map");
}
}
// migrate secondary storages NFS from host tables to image_store table
private void migrateSecondaryStorageToImageStore(Connection conn) {
PreparedStatement storeInsert = null;
PreparedStatement storeDetailInsert = null;
PreparedStatement nfsQuery = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
ResultSet storeInfo = null;
s_logger.debug("Migrating secondary storage to image store");
boolean hasS3orSwift = false;
try {
s_logger.debug("Checking if we need to migrate NFS secondary storage to image store or staging store");
int numRows = 0;
pstmt = conn.prepareStatement("select count(*) from `cloud`.`s3`");
rs = pstmt.executeQuery();
if (rs.next()) {
numRows = rs.getInt(1);
}
rs.close();
pstmt.close();
if (numRows > 0) {
hasS3orSwift = true;
} else {
// check if there is swift storage
pstmt = conn.prepareStatement("select count(*) from `cloud`.`swift`");
rs = pstmt.executeQuery();
if (rs.next()) {
numRows = rs.getInt(1);
}
rs.close();
pstmt.close();
if (numRows > 0) {
hasS3orSwift = true;
}
}
String store_role = "Image";
if (hasS3orSwift) {
store_role = "ImageCache";
}
s_logger.debug("Migrating NFS secondary storage to " + store_role + " store");
storeDetailInsert = conn.prepareStatement("INSERT INTO `cloud`.`image_store_details` (store_id, name, value) values(?, ?, ?)");
// migrate NFS secondary storage, for nfs, keep previous host_id as the store_id
storeInsert =
conn.prepareStatement("INSERT INTO `cloud`.`image_store` (id, uuid, name, image_provider_name, protocol, url, data_center_id, scope, role, parent, total_size, created) values(?, ?, ?, 'NFS', 'nfs', ?, ?, 'ZONE', ?, ?, ?, ?)");
nfsQuery =
conn.prepareStatement("select id, uuid, url, data_center_id, parent, total_size, created from `cloud`.`host` where type = 'SecondaryStorage' and removed is null");
rs = nfsQuery.executeQuery();
while (rs.next()) {
Long nfs_id = rs.getLong("id");
String nfs_uuid = rs.getString("uuid");
String nfs_url = rs.getString("url");
String nfs_parent = rs.getString("parent");
int nfs_dcid = rs.getInt("data_center_id");
Long nfs_totalsize = rs.getObject("total_size") != null ? rs.getLong("total_size") : null;
Date nfs_created = rs.getDate("created");
// insert entry in image_store table and image_store_details
// table and store host_id and store_id mapping
storeInsert.setLong(1, nfs_id);
storeInsert.setString(2, nfs_uuid);
storeInsert.setString(3, nfs_uuid);
storeInsert.setString(4, nfs_url);
storeInsert.setInt(5, nfs_dcid);
storeInsert.setString(6, store_role);
storeInsert.setString(7, nfs_parent);
if (nfs_totalsize != null) {
storeInsert.setLong(8, nfs_totalsize);
} else {
storeInsert.setNull(8, Types.BIGINT);
}
storeInsert.setDate(9, nfs_created);
storeInsert.executeUpdate();
}
s_logger.debug("Marking NFS secondary storage in host table as removed");
pstmt = conn.prepareStatement("UPDATE `cloud`.`host` SET removed = now() WHERE type = 'SecondaryStorage' and removed is null");
pstmt.executeUpdate();
pstmt.close();
} catch (SQLException e) {
String msg = "Unable to migrate secondary storages." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (storeInfo != null) {
storeInfo.close();
}
if (storeInsert != null) {
storeInsert.close();
}
if (storeDetailInsert != null) {
storeDetailInsert.close();
}
if (nfsQuery != null) {
nfsQuery.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Completed migrating secondary storage to image store");
}
// migrate volume_host_ref to volume_store_ref
private void migrateVolumeHostRef(Connection conn) {
PreparedStatement volStoreInsert = null;
PreparedStatement volStoreUpdate = null;
s_logger.debug("Updating volume_store_ref table from volume_host_ref table");
try {
volStoreInsert =
conn.prepareStatement("INSERT INTO `cloud`.`volume_store_ref` (store_id, volume_id, zone_id, created, last_updated, job_id, download_pct, size, physical_size, download_state, checksum, error_str, local_path, install_path, url, destroyed, update_count, ref_cnt, state) select host_id, volume_id, zone_id, created, last_updated, job_id, download_pct, size, physical_size, download_state, checksum, error_str, local_path, install_path, url, destroyed, 0, 0, 'Allocated' from `cloud`.`volume_host_ref`");
int rowCount = volStoreInsert.executeUpdate();
s_logger.debug("Insert modified " + rowCount + " rows");
volStoreUpdate = conn.prepareStatement("update `cloud`.`volume_store_ref` set state = 'Ready' where download_state = 'DOWNLOADED'");
rowCount = volStoreUpdate.executeUpdate();
s_logger.debug("Update modified " + rowCount + " rows");
} catch (SQLException e) {
String msg = "Unable to migrate volume_host_ref." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (volStoreInsert != null) {
volStoreInsert.close();
}
if (volStoreUpdate != null) {
volStoreUpdate.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Completed updating volume_store_ref table from volume_host_ref table");
}
// migrate template_host_ref to template_store_ref
private void migrateTemplateHostRef(Connection conn) {
PreparedStatement tmplStoreInsert = null;
PreparedStatement tmplStoreUpdate = null;
s_logger.debug("Updating template_store_ref table from template_host_ref table");
try {
tmplStoreInsert =
conn.prepareStatement("INSERT INTO `cloud`.`template_store_ref` (store_id, template_id, created, last_updated, job_id, download_pct, size, physical_size, download_state, error_str, local_path, install_path, url, destroyed, is_copy, update_count, ref_cnt, store_role, state) select host_id, template_id, created, last_updated, job_id, download_pct, size, physical_size, download_state, error_str, local_path, install_path, url, destroyed, is_copy, 0, 0, 'Image', 'Allocated' from `cloud`.`template_host_ref`");
int rowCount = tmplStoreInsert.executeUpdate();
s_logger.debug("Insert modified " + rowCount + " rows");
tmplStoreUpdate = conn.prepareStatement("update `cloud`.`template_store_ref` set state = 'Ready' where download_state = 'DOWNLOADED'");
rowCount = tmplStoreUpdate.executeUpdate();
s_logger.debug("Update modified " + rowCount + " rows");
} catch (SQLException e) {
String msg = "Unable to migrate template_host_ref." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (tmplStoreInsert != null) {
tmplStoreInsert.close();
}
if (tmplStoreUpdate != null) {
tmplStoreUpdate.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Completed updating template_store_ref table from template_host_ref table");
}
// migrate some entry contents of snapshots to snapshot_store_ref
private void migrateSnapshotStoreRef(Connection conn) {
PreparedStatement snapshotStoreInsert = null;
s_logger.debug("Updating snapshot_store_ref table from snapshots table");
try {
//Update all snapshots except KVM snapshots
snapshotStoreInsert =
conn.prepareStatement("INSERT INTO `cloud`.`snapshot_store_ref` (store_id, snapshot_id, created, size, parent_snapshot_id, install_path, volume_id, update_count, ref_cnt, store_role, state) select sechost_id, id, created, size, prev_snap_id, CONCAT('snapshots', '/', account_id, '/', volume_id, '/', backup_snap_id), volume_id, 0, 0, 'Image', 'Ready' from `cloud`.`snapshots` where status = 'BackedUp' and hypervisor_type <> 'KVM' and sechost_id is not null and removed is null");
int rowCount = snapshotStoreInsert.executeUpdate();
s_logger.debug("Inserted " + rowCount + " snapshots into snapshot_store_ref");
//backsnap_id for KVM snapshots is complate path. CONCAT is not required
snapshotStoreInsert =
conn.prepareStatement("INSERT INTO `cloud`.`snapshot_store_ref` (store_id, snapshot_id, created, size, parent_snapshot_id, install_path, volume_id, update_count, ref_cnt, store_role, state) select sechost_id, id, created, size, prev_snap_id, backup_snap_id, volume_id, 0, 0, 'Image', 'Ready' from `cloud`.`snapshots` where status = 'BackedUp' and hypervisor_type = 'KVM' and sechost_id is not null and removed is null");
rowCount = snapshotStoreInsert.executeUpdate();
s_logger.debug("Inserted " + rowCount + " KVM snapshots into snapshot_store_ref");
} catch (SQLException e) {
String msg = "Unable to migrate snapshot_store_ref." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (snapshotStoreInsert != null) {
snapshotStoreInsert.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Completed updating snapshot_store_ref table from snapshots table");
}
// migrate secondary storages S3 from s3 tables to image_store table
private void migrateS3ToImageStore(Connection conn) {
PreparedStatement storeInsert = null;
PreparedStatement storeDetailInsert = null;
PreparedStatement storeQuery = null;
PreparedStatement s3Query = null;
ResultSet rs = null;
ResultSet storeInfo = null;
Long storeId = null;
Map<Long, Long> s3_store_id_map = new HashMap<Long, Long>();
s_logger.debug("Migrating S3 to image store");
try {
storeQuery = conn.prepareStatement("select id from `cloud`.`image_store` where uuid = ?");
storeDetailInsert = conn.prepareStatement("INSERT INTO `cloud`.`image_store_details` (store_id, name, value) values(?, ?, ?)");
// migrate S3 to image_store
storeInsert = conn.prepareStatement("INSERT INTO `cloud`.`image_store` (uuid, name, image_provider_name, protocol, scope, role, created) " +
"values(?, ?, 'S3', ?, 'REGION', 'Image', ?)");
s3Query = conn.prepareStatement("select id, uuid, access_key, secret_key, end_point, bucket, https, connection_timeout, " +
"max_error_retry, socket_timeout, created from `cloud`.`s3`");
rs = s3Query.executeQuery();
while (rs.next()) {
Long s3_id = rs.getLong("id");
String s3_uuid = rs.getString("uuid");
String s3_accesskey = rs.getString("access_key");
String s3_secretkey = rs.getString("secret_key");
String s3_endpoint = rs.getString("end_point");
String s3_bucket = rs.getString("bucket");
boolean s3_https = rs.getObject("https") != null ? (rs.getInt("https") == 0 ? false : true) : false;
Integer s3_connectiontimeout = rs.getObject("connection_timeout") != null ? rs.getInt("connection_timeout") : null;
Integer s3_retry = rs.getObject("max_error_retry") != null ? rs.getInt("max_error_retry") : null;
Integer s3_sockettimeout = rs.getObject("socket_timeout") != null ? rs.getInt("socket_timeout") : null;
Date s3_created = rs.getDate("created");
// insert entry in image_store table and image_store_details
// table and store s3_id and store_id mapping
storeInsert.setString(1, s3_uuid);
storeInsert.setString(2, s3_uuid);
storeInsert.setString(3, s3_https ? "https" : "http");
storeInsert.setDate(4, s3_created);
storeInsert.executeUpdate();
storeQuery.setString(1, s3_uuid);
storeInfo = storeQuery.executeQuery();
if (storeInfo.next()) {
storeId = storeInfo.getLong("id");
}
Map<String, String> detailMap = new HashMap<String, String>();
detailMap.put(ApiConstants.S3_ACCESS_KEY, s3_accesskey);
detailMap.put(ApiConstants.S3_SECRET_KEY, s3_secretkey);
detailMap.put(ApiConstants.S3_BUCKET_NAME, s3_bucket);
detailMap.put(ApiConstants.S3_END_POINT, s3_endpoint);
detailMap.put(ApiConstants.S3_HTTPS_FLAG, String.valueOf(s3_https));
if (s3_connectiontimeout != null) {
detailMap.put(ApiConstants.S3_CONNECTION_TIMEOUT, String.valueOf(s3_connectiontimeout));
}
if (s3_retry != null) {
detailMap.put(ApiConstants.S3_MAX_ERROR_RETRY, String.valueOf(s3_retry));
}
if (s3_sockettimeout != null) {
detailMap.put(ApiConstants.S3_SOCKET_TIMEOUT, String.valueOf(s3_sockettimeout));
}
Iterator<String> keyIt = detailMap.keySet().iterator();
while (keyIt.hasNext()) {
String key = keyIt.next();
String val = detailMap.get(key);
storeDetailInsert.setLong(1, storeId);
storeDetailInsert.setString(2, key);
storeDetailInsert.setString(3, val);
storeDetailInsert.executeUpdate();
}
s3_store_id_map.put(s3_id, storeId);
}
} catch (SQLException e) {
String msg = "Unable to migrate S3 secondary storages." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (storeInfo != null) {
storeInfo.close();
}
if (storeInsert != null) {
storeInsert.close();
}
if (storeDetailInsert != null) {
storeDetailInsert.close();
}
if (storeQuery != null) {
storeQuery.close();
}
if (s3Query != null) {
s3Query.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Migrating template_s3_ref to template_store_ref");
migrateTemplateS3Ref(conn, s3_store_id_map);
s_logger.debug("Migrating s3 backedup snapshots to snapshot_store_ref");
migrateSnapshotS3Ref(conn, s3_store_id_map);
s_logger.debug("Completed migrating S3 secondary storage to image store");
}
// migrate template_s3_ref to template_store_ref
private void migrateTemplateS3Ref(Connection conn, Map<Long, Long> s3StoreMap) {
PreparedStatement tmplStoreInsert = null;
PreparedStatement s3Query = null;
ResultSet rs = null;
s_logger.debug("Updating template_store_ref table from template_s3_ref table");
try {
tmplStoreInsert =
conn.prepareStatement("INSERT INTO `cloud`.`template_store_ref` (store_id, template_id, created, download_pct, size, physical_size, download_state, local_path, install_path, update_count, ref_cnt, store_role, state) values(?, ?, ?, 100, ?, ?, 'DOWNLOADED', '?', '?', 0, 0, 'Image', 'Ready')");
s3Query =
conn.prepareStatement("select template_s3_ref.s3_id, template_s3_ref.template_id, template_s3_ref.created, template_s3_ref.size, template_s3_ref.physical_size, vm_template.account_id from `cloud`.`template_s3_ref`, `cloud`.`vm_template` where vm_template.id = template_s3_ref.template_id");
rs = s3Query.executeQuery();
while (rs.next()) {
Long s3_id = rs.getLong("s3_id");
Long s3_tmpl_id = rs.getLong("template_id");
Date s3_created = rs.getDate("created");
Long s3_size = rs.getObject("size") != null ? rs.getLong("size") : null;
Long s3_psize = rs.getObject("physical_size") != null ? rs.getLong("physical_size") : null;
Long account_id = rs.getLong("account_id");
tmplStoreInsert.setLong(1, s3StoreMap.get(s3_id));
tmplStoreInsert.setLong(2, s3_tmpl_id);
tmplStoreInsert.setDate(3, s3_created);
if (s3_size != null) {
tmplStoreInsert.setLong(4, s3_size);
} else {
tmplStoreInsert.setNull(4, Types.BIGINT);
}
if (s3_psize != null) {
tmplStoreInsert.setLong(5, s3_psize);
} else {
tmplStoreInsert.setNull(5, Types.BIGINT);
}
String path = "template/tmpl/" + account_id + "/" + s3_tmpl_id;
tmplStoreInsert.setString(6, path);
tmplStoreInsert.setString(7, path);
tmplStoreInsert.executeUpdate();
}
} catch (SQLException e) {
String msg = "Unable to migrate template_s3_ref." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (tmplStoreInsert != null) {
tmplStoreInsert.close();
}
if (s3Query != null) {
s3Query.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Completed migrating template_s3_ref table.");
}
// migrate some entry contents of snapshots to snapshot_store_ref
private void migrateSnapshotS3Ref(Connection conn, Map<Long, Long> s3StoreMap) {
PreparedStatement snapshotStoreInsert = null;
PreparedStatement s3Query = null;
ResultSet rs = null;
s_logger.debug("Updating snapshot_store_ref table from snapshots table for s3");
try {
snapshotStoreInsert =
conn.prepareStatement("INSERT INTO `cloud`.`snapshot_store_ref` (store_id, snapshot_id, created, size, parent_snapshot_id, install_path, volume_id, update_count, ref_cnt, store_role, state) values(?, ?, ?, ?, ?, ?, ?, 0, 0, 'Image', 'Ready')");
s3Query =
conn.prepareStatement("select s3_id, id, created, size, prev_snap_id, CONCAT('snapshots', '/', account_id, '/', volume_id, '/', backup_snap_id), volume_id, 0, 0, 'Image', 'Ready' from `cloud`.`snapshots` where status = 'BackedUp' and hypervisor_type <> 'KVM' and s3_id is not null and removed is null");
rs = s3Query.executeQuery();
while (rs.next()) {
Long s3_id = rs.getLong("s3_id");
Long snapshot_id = rs.getLong("id");
Date s3_created = rs.getDate("created");
Long s3_size = rs.getObject("size") != null ? rs.getLong("size") : null;
Long s3_prev_id = rs.getObject("prev_snap_id") != null ? rs.getLong("prev_snap_id") : null;
String install_path = rs.getString(6);
Long s3_vol_id = rs.getLong("volume_id");
snapshotStoreInsert.setLong(1, s3StoreMap.get(s3_id));
snapshotStoreInsert.setLong(2, snapshot_id);
snapshotStoreInsert.setDate(3, s3_created);
if (s3_size != null) {
snapshotStoreInsert.setLong(4, s3_size);
} else {
snapshotStoreInsert.setNull(4, Types.BIGINT);
}
if (s3_prev_id != null) {
snapshotStoreInsert.setLong(5, s3_prev_id);
} else {
snapshotStoreInsert.setNull(5, Types.BIGINT);
}
snapshotStoreInsert.setString(6, install_path);
snapshotStoreInsert.setLong(7, s3_vol_id);
snapshotStoreInsert.executeUpdate();
}
} catch (SQLException e) {
String msg = "Unable to migrate s3 backedup snapshots to snapshot_store_ref." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (snapshotStoreInsert != null) {
snapshotStoreInsert.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Completed updating snapshot_store_ref table from s3 snapshots entries");
}
// migrate secondary storages Swift from swift tables to image_store table
private void migrateSwiftToImageStore(Connection conn) {
PreparedStatement storeInsert = null;
PreparedStatement storeDetailInsert = null;
PreparedStatement storeQuery = null;
PreparedStatement swiftQuery = null;
ResultSet rs = null;
ResultSet storeInfo = null;
Long storeId = null;
Map<Long, Long> swift_store_id_map = new HashMap<Long, Long>();
s_logger.debug("Migrating Swift to image store");
try {
storeQuery = conn.prepareStatement("select id from `cloud`.`image_store` where uuid = ?");
storeDetailInsert = conn.prepareStatement("INSERT INTO `cloud`.`image_store_details` (store_id, name, value) values(?, ?, ?)");
// migrate SWIFT secondary storage
storeInsert =
conn.prepareStatement("INSERT INTO `cloud`.`image_store` (uuid, name, image_provider_name, protocol, url, scope, role, created) values(?, ?, 'Swift', 'http', ?, 'REGION', 'Image', ?)");
swiftQuery = conn.prepareStatement("select id, uuid, url, account, username, swift.key, created from `cloud`.`swift`");
rs = swiftQuery.executeQuery();
while (rs.next()) {
Long swift_id = rs.getLong("id");
String swift_uuid = rs.getString("uuid");
String swift_url = rs.getString("url");
String swift_account = rs.getString("account");
String swift_username = rs.getString("username");
String swift_key = rs.getString("key");
Date swift_created = rs.getDate("created");
// insert entry in image_store table and image_store_details
// table and store swift_id and store_id mapping
storeInsert.setString(1, swift_uuid);
storeInsert.setString(2, swift_uuid);
storeInsert.setString(3, swift_url);
storeInsert.setDate(4, swift_created);
storeInsert.executeUpdate();
storeQuery.setString(1, swift_uuid);
storeInfo = storeQuery.executeQuery();
if (storeInfo.next()) {
storeId = storeInfo.getLong("id");
}
Map<String, String> detailMap = new HashMap<String, String>();
detailMap.put(ApiConstants.ACCOUNT, swift_account);
detailMap.put(ApiConstants.USERNAME, swift_username);
detailMap.put(ApiConstants.KEY, swift_key);
Iterator<String> keyIt = detailMap.keySet().iterator();
while (keyIt.hasNext()) {
String key = keyIt.next();
String val = detailMap.get(key);
storeDetailInsert.setLong(1, storeId);
storeDetailInsert.setString(2, key);
storeDetailInsert.setString(3, val);
storeDetailInsert.executeUpdate();
}
swift_store_id_map.put(swift_id, storeId);
}
} catch (SQLException e) {
String msg = "Unable to migrate swift secondary storages." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (storeInfo != null) {
storeInfo.close();
}
if (storeInsert != null) {
storeInsert.close();
}
if (storeDetailInsert != null) {
storeDetailInsert.close();
}
if (storeQuery != null) {
storeQuery.close();
}
if (swiftQuery != null) {
swiftQuery.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Migrating template_swift_ref to template_store_ref");
migrateTemplateSwiftRef(conn, swift_store_id_map);
s_logger.debug("Migrating swift backedup snapshots to snapshot_store_ref");
migrateSnapshotSwiftRef(conn, swift_store_id_map);
s_logger.debug("Completed migrating Swift secondary storage to image store");
}
// migrate template_s3_ref to template_store_ref
private void migrateTemplateSwiftRef(Connection conn, Map<Long, Long> swiftStoreMap) {
PreparedStatement tmplStoreInsert = null;
PreparedStatement s3Query = null;
ResultSet rs = null;
s_logger.debug("Updating template_store_ref table from template_swift_ref table");
try {
tmplStoreInsert =
conn.prepareStatement("INSERT INTO `cloud`.`template_store_ref` (store_id, template_id, created, download_pct, size, physical_size, download_state, local_path, install_path, update_count, ref_cnt, store_role, state) values(?, ?, ?, 100, ?, ?, 'DOWNLOADED', '?', '?', 0, 0, 'Image', 'Ready')");
s3Query = conn.prepareStatement("select swift_id, template_id, created, path, size, physical_size from `cloud`.`template_swift_ref`");
rs = s3Query.executeQuery();
while (rs.next()) {
Long swift_id = rs.getLong("swift_id");
Long tmpl_id = rs.getLong("template_id");
Date created = rs.getDate("created");
String path = rs.getString("path");
Long size = rs.getObject("size") != null ? rs.getLong("size") : null;
Long psize = rs.getObject("physical_size") != null ? rs.getLong("physical_size") : null;
tmplStoreInsert.setLong(1, swiftStoreMap.get(swift_id));
tmplStoreInsert.setLong(2, tmpl_id);
tmplStoreInsert.setDate(3, created);
if (size != null) {
tmplStoreInsert.setLong(4, size);
} else {
tmplStoreInsert.setNull(4, Types.BIGINT);
}
if (psize != null) {
tmplStoreInsert.setLong(5, psize);
} else {
tmplStoreInsert.setNull(5, Types.BIGINT);
}
tmplStoreInsert.setString(6, path);
tmplStoreInsert.setString(7, path);
tmplStoreInsert.executeUpdate();
}
} catch (SQLException e) {
String msg = "Unable to migrate template_swift_ref." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (tmplStoreInsert != null) {
tmplStoreInsert.close();
}
if (s3Query != null) {
s3Query.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Completed migrating template_swift_ref table.");
}
// migrate some entry contents of snapshots to snapshot_store_ref
private void migrateSnapshotSwiftRef(Connection conn, Map<Long, Long> swiftStoreMap) {
PreparedStatement snapshotStoreInsert = null;
PreparedStatement s3Query = null;
ResultSet rs = null;
s_logger.debug("Updating snapshot_store_ref table from snapshots table for swift");
try {
snapshotStoreInsert =
conn.prepareStatement("INSERT INTO `cloud`.`snapshot_store_ref` (store_id, snapshot_id, created, size, parent_snapshot_id, install_path, volume_id, update_count, ref_cnt, store_role, state) values(?, ?, ?, ?, ?, ?, ?, 0, 0, 'Image', 'Ready')");
s3Query =
conn.prepareStatement("select swift_id, id, created, size, prev_snap_id, CONCAT('snapshots', '/', account_id, '/', volume_id, '/', backup_snap_id), volume_id, 0, 0, 'Image', 'Ready' from `cloud`.`snapshots` where status = 'BackedUp' and hypervisor_type <> 'KVM' and swift_id is not null and removed is null");
rs = s3Query.executeQuery();
while (rs.next()) {
Long swift_id = rs.getLong("swift_id");
Long snapshot_id = rs.getLong("id");
Date created = rs.getDate("created");
Long size = rs.getLong("size");
Long prev_id = rs.getLong("prev_snap_id");
String install_path = rs.getString(6);
Long vol_id = rs.getLong("volume_id");
snapshotStoreInsert.setLong(1, swiftStoreMap.get(swift_id));
snapshotStoreInsert.setLong(2, snapshot_id);
snapshotStoreInsert.setDate(3, created);
snapshotStoreInsert.setLong(4, size);
snapshotStoreInsert.setLong(5, prev_id);
snapshotStoreInsert.setString(6, install_path);
snapshotStoreInsert.setLong(7, vol_id);
snapshotStoreInsert.executeUpdate();
}
} catch (SQLException e) {
String msg = "Unable to migrate swift backedup snapshots to snapshot_store_ref." + e.getMessage();
s_logger.error(msg);
throw new CloudRuntimeException(msg, e);
} finally {
try {
if (snapshotStoreInsert != null) {
snapshotStoreInsert.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Completed updating snapshot_store_ref table from swift snapshots entries");
}
private void fixNiciraKeys(Connection conn) {
//First drop the key if it exists.
List<String> keys = new ArrayList<String>();
s_logger.debug("Dropping foreign key fk_nicira_nvp_nic_map__nic from the table nicira_nvp_nic_map if it exists");
keys.add("fk_nicira_nvp_nic_map__nic");
DbUpgradeUtils.dropKeysIfExist(conn, "nicira_nvp_nic_map", keys, true);
//Now add foreign key.
PreparedStatement pstmt = null;
try {
pstmt =
conn.prepareStatement("ALTER TABLE `cloud`.`nicira_nvp_nic_map` ADD CONSTRAINT `fk_nicira_nvp_nic_map__nic` FOREIGN KEY (`nic`) REFERENCES `nics` (`uuid`) ON DELETE CASCADE");
pstmt.executeUpdate();
s_logger.debug("Added foreign key fk_nicira_nvp_nic_map__nic to the table nicira_nvp_nic_map");
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to add foreign key fk_nicira_nvp_nic_map__nic to the table nicira_nvp_nic_map", e);
} finally {
try {
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void fixRouterKeys(Connection conn) {
//First drop the key if it exists.
List<String> keys = new ArrayList<String>();
s_logger.debug("Dropping foreign key fk_router_network_ref__router_id from the table router_network_ref if it exists");
keys.add("fk_router_network_ref__router_id");
DbUpgradeUtils.dropKeysIfExist(conn, "router_network_ref", keys, true);
//Now add foreign key.
PreparedStatement pstmt = null;
try {
pstmt =
conn.prepareStatement("ALTER TABLE `cloud`.`router_network_ref` ADD CONSTRAINT `fk_router_network_ref__router_id` FOREIGN KEY (`router_id`) REFERENCES `domain_router` (`id`) ON DELETE CASCADE");
pstmt.executeUpdate();
s_logger.debug("Added foreign key fk_router_network_ref__router_id to the table router_network_ref");
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to add foreign key fk_router_network_ref__router_id to the table router_network_ref", e);
} finally {
try {
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void encryptSite2SitePSK(Connection conn) {
s_logger.debug("Encrypting Site2Site Customer Gateway pre-shared key");
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = conn.prepareStatement("select id, ipsec_psk from `cloud`.`s2s_customer_gateway`");
rs = pstmt.executeQuery();
while (rs.next()) {
long id = rs.getLong(1);
String value = rs.getString(2);
if (value == null) {
continue;
}
String encryptedValue = DBEncryptionUtil.encrypt(value);
pstmt = conn.prepareStatement("update `cloud`.`s2s_customer_gateway` set ipsec_psk=? where id=?");
pstmt.setBytes(1, encryptedValue.getBytes("UTF-8"));
pstmt.setLong(2, id);
pstmt.executeUpdate();
}
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to encrypt Site2Site Customer Gateway pre-shared key ", e);
} catch (UnsupportedEncodingException e) {
throw new CloudRuntimeException("Unable to encrypt Site2Site Customer Gateway pre-shared key ", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
s_logger.debug("Done encrypting Site2Site Customer Gateway pre-shared key");
}
protected void updateConcurrentConnectionsInNetworkOfferings(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
ResultSet rs1 = null;
ResultSet rs2 = null;
try {
try {
pstmt =
conn.prepareStatement("SELECT * FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = 'cloud' AND TABLE_NAME = 'network_offerings' AND COLUMN_NAME = 'concurrent_connections'");
rs = pstmt.executeQuery();
if (!rs.next()) {
pstmt =
conn.prepareStatement("ALTER TABLE `cloud`.`network_offerings` ADD COLUMN `concurrent_connections` int(10) unsigned COMMENT 'Load Balancer(haproxy) maximum number of concurrent connections(global max)'");
pstmt.executeUpdate();
}
} catch (SQLException e) {
throw new CloudRuntimeException("migration of concurrent connections from network_detais failed");
}
pstmt = conn.prepareStatement("select network_id, value from `cloud`.`network_details` where name='maxconnections'");
rs = pstmt.executeQuery();
while (rs.next()) {
long networkId = rs.getLong(1);
int maxconnections = Integer.parseInt(rs.getString(2));
pstmt = conn.prepareStatement("select network_offering_id from `cloud`.`networks` where id= ?");
pstmt.setLong(1, networkId);
rs1 = pstmt.executeQuery();
if (rs1.next()) {
long network_offering_id = rs1.getLong(1);
pstmt = conn.prepareStatement("select concurrent_connections from `cloud`.`network_offerings` where id= ?");
pstmt.setLong(1, network_offering_id);
rs2 = pstmt.executeQuery();
if ((!rs2.next()) || (rs2.getInt(1) < maxconnections)) {
pstmt = conn.prepareStatement("update network_offerings set concurrent_connections=? where id=?");
pstmt.setInt(1, maxconnections);
pstmt.setLong(2, network_offering_id);
pstmt.executeUpdate();
}
}
}
} catch (SQLException e) {
} finally {
try {
if (rs != null) {
rs.close();
}
if (rs1 != null) {
rs1.close();
}
if (pstmt != null) {
pstmt.close();
}
} catch (SQLException e) {
}
}
}
private void migrateDatafromIsoIdInVolumesTable(Connection conn) {
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
pstmt = conn.prepareStatement("SELECT iso_id1 From `cloud`.`volumes`");
rs = pstmt.executeQuery();
if (rs.next()) {
pstmt = conn.prepareStatement("ALTER TABLE `cloud`.`volumes` DROP COLUMN `iso_id`");
pstmt.executeUpdate();
pstmt =
conn.prepareStatement("ALTER TABLE `cloud`.`volumes` CHANGE COLUMN `iso_id1` `iso_id` bigint(20) unsigned COMMENT 'The id of the iso from which the volume was created'");
pstmt.executeUpdate();
}
} catch (SQLException e) {
//implies iso_id1 is not present, so do nothing.
}
}
protected void setRAWformatForRBDVolumes(Connection conn) {
PreparedStatement pstmt = null;
try {
s_logger.debug("Setting format to RAW for all volumes on RBD primary storage pools");
pstmt = conn.prepareStatement("UPDATE volumes SET format = 'RAW' WHERE pool_id IN(SELECT id FROM storage_pool WHERE pool_type = 'RBD')");
pstmt.executeUpdate();
} catch (SQLException e) {
throw new CloudRuntimeException("Failed to update volume format to RAW for volumes on RBD pools due to exception ", e);
}
}
private void upgradeVpcServiceMap(Connection conn) {
s_logger.debug("Upgrading VPC service Map");
PreparedStatement listVpc = null;
PreparedStatement listServiceProviders = null;
PreparedStatement insertProviders = null;
ResultSet rs = null;
ResultSet rs1 = null;
try {
//Get all vpc Ids along with vpc offering Id
listVpc = conn.prepareStatement("SELECT id, vpc_offering_id FROM `cloud`.`vpc` where removed is NULL");
rs = listVpc.executeQuery();
while (rs.next()) {
long vpc_id = rs.getLong(1);
long offering_id = rs.getLong(2);
//list all services and providers in offering
listServiceProviders = conn.prepareStatement("SELECT service, provider FROM `cloud`.`vpc_offering_service_map` where vpc_offering_id = ?");
listServiceProviders.setLong(1, offering_id);
rs1 = listServiceProviders.executeQuery();
//Insert entries in vpc_service_map
while (rs1.next()) {
String service = rs1.getString(1);
String provider = rs1.getString(2);
insertProviders =
conn.prepareStatement("INSERT INTO `cloud`.`vpc_service_map` (`vpc_id`, `service`, `provider`, `created`) VALUES (?, ?, ?, now());");
insertProviders.setLong(1, vpc_id);
insertProviders.setString(2, service);
insertProviders.setString(3, provider);
insertProviders.executeUpdate();
}
s_logger.debug("Upgraded service map for VPC: " + vpc_id);
}
} catch (SQLException e) {
throw new CloudRuntimeException("Error during VPC service map upgrade", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (rs1 != null) {
rs1.close();
}
if (listVpc != null) {
listVpc.close();
}
if (listServiceProviders != null) {
listServiceProviders.close();
}
if (insertProviders != null) {
insertProviders.close();
}
} catch (SQLException e) {
}
}
}
private void upgradeResourceCount(Connection conn) {
s_logger.debug("upgradeResourceCount start");
PreparedStatement pstmt1 = null;
PreparedStatement pstmt2 = null;
PreparedStatement pstmt3 = null;
PreparedStatement pstmt4 = null;
PreparedStatement pstmt5 = null;
ResultSet rs = null;
ResultSet rsAccount = null;
ResultSet rsCount = null;
try {
pstmt1 = conn.prepareStatement("select id, domain_id FROM `cloud`.`account` where removed is NULL ");
rsAccount = pstmt1.executeQuery();
while (rsAccount.next()) {
long account_id = rsAccount.getLong(1);
long domain_id = rsAccount.getLong(2);
// 1. update cpu,memory for all accounts
pstmt2 =
conn.prepareStatement("SELECT SUM(service_offering.cpu), SUM(service_offering.ram_size)" + " FROM `cloud`.`vm_instance`, `cloud`.`service_offering`"
+ " WHERE vm_instance.service_offering_id = service_offering.id AND vm_instance.account_id = ?" + " AND vm_instance.removed is NULL"
+ " AND vm_instance.vm_type='User' AND state not in ('Destroyed', 'Error', 'Expunging')");
pstmt2.setLong(1, account_id);
rsCount = pstmt2.executeQuery();
if (rsCount.next()) {
upgradeResourceCountforAccount(conn, account_id, domain_id, "cpu", rsCount.getLong(1));
upgradeResourceCountforAccount(conn, account_id, domain_id, "memory", rsCount.getLong(2));
} else {
upgradeResourceCountforAccount(conn, account_id, domain_id, "cpu", 0L);
upgradeResourceCountforAccount(conn, account_id, domain_id, "memory", 0L);
}
// 2. update primary_storage for all accounts
pstmt3 =
conn.prepareStatement("SELECT sum(size) FROM `cloud`.`volumes` WHERE account_id= ?"
+ " AND (path is not NULL OR state in ('Allocated')) AND removed is NULL"
+ " AND instance_id IN (SELECT id FROM `cloud`.`vm_instance` WHERE vm_type='User')");
pstmt3.setLong(1, account_id);
rsCount = pstmt3.executeQuery();
if (rsCount.next()) {
upgradeResourceCountforAccount(conn, account_id, domain_id, "primary_storage", rsCount.getLong(1));
} else {
upgradeResourceCountforAccount(conn, account_id, domain_id, "primary_storage", 0L);
}
// 3. update secondary_storage for all accounts
long totalVolumesSize = 0;
long totalSnapshotsSize = 0;
long totalTemplatesSize = 0;
pstmt4 =
conn.prepareStatement("SELECT sum(size) FROM `cloud`.`volumes` WHERE account_id= ?"
+ " AND path is NULL AND state not in ('Allocated') AND removed is NULL");
pstmt4.setLong(1, account_id);
rsCount = pstmt4.executeQuery();
if (rsCount.next()) {
totalVolumesSize = rsCount.getLong(1);
}
pstmt4 = conn.prepareStatement("SELECT sum(size) FROM `cloud`.`snapshots` WHERE account_id= ? AND removed is NULL");
pstmt4.setLong(1, account_id);
rsCount = pstmt4.executeQuery();
if (rsCount.next()) {
totalSnapshotsSize = rsCount.getLong(1);
}
pstmt4 =
conn.prepareStatement("SELECT sum(template_store_ref.size) FROM `cloud`.`template_store_ref`,`cloud`.`vm_template` WHERE account_id = ?"
+ " AND template_store_ref.template_id = vm_template.id AND download_state = 'DOWNLOADED' AND destroyed = false AND removed is NULL");
pstmt4.setLong(1, account_id);
rsCount = pstmt4.executeQuery();
if (rsCount.next()) {
totalTemplatesSize = rsCount.getLong(1);
}
upgradeResourceCountforAccount(conn, account_id, domain_id, "secondary_storage", totalVolumesSize + totalSnapshotsSize + totalTemplatesSize);
}
// 4. upgrade cpu,memory,primary_storage,secondary_storage for domains
String resource_types[] = {"cpu", "memory", "primary_storage", "secondary_storage"};
pstmt5 = conn.prepareStatement("select id FROM `cloud`.`domain`");
rsAccount = pstmt5.executeQuery();
while (rsAccount.next()) {
long domain_id = rsAccount.getLong(1);
for (int count = 0; count < resource_types.length; count++) {
String resource_type = resource_types[count];
upgradeResourceCountforDomain(conn, domain_id, resource_type, 0L); // reset value to 0 before statistics
}
}
for (int count = 0; count < resource_types.length; count++) {
String resource_type = resource_types[count];
pstmt5 =
conn.prepareStatement("select account.domain_id,sum(resource_count.count) from `cloud`.`account` left join `cloud`.`resource_count` on account.id=resource_count.account_id "
+ "where resource_count.type=? group by account.domain_id;");
pstmt5.setString(1, resource_type);
rsCount = pstmt5.executeQuery();
while (rsCount.next()) {
long domain_id = rsCount.getLong(1);
long resource_count = rsCount.getLong(2);
upgradeResourceCountforDomain(conn, domain_id, resource_type, resource_count);
}
}
s_logger.debug("upgradeResourceCount finish");
} catch (SQLException e) {
throw new CloudRuntimeException("Unable to upgrade resource count (cpu,memory,primary_storage,secondary_storage) ", e);
} finally {
try {
if (rs != null) {
rs.close();
}
if (rsAccount != null) {
rsAccount.close();
}
if (rsCount != null) {
rsCount.close();
}
if (pstmt1 != null) {
pstmt1.close();
}
if (pstmt2 != null) {
pstmt2.close();
}
if (pstmt3 != null) {
pstmt3.close();
}
if (pstmt4 != null) {
pstmt4.close();
}
if (pstmt5 != null) {
pstmt5.close();
}
} catch (SQLException e) {
}
}
}
private static void upgradeResourceCountforAccount(Connection conn, Long accountId, Long domainId, String type, Long resourceCount) throws SQLException {
//update or insert into resource_count table.
PreparedStatement pstmt = null;
pstmt =
conn.prepareStatement("INSERT INTO `cloud`.`resource_count` (account_id, type, count) VALUES (?,?,?) ON DUPLICATE KEY UPDATE id=LAST_INSERT_ID(id), count=?");
pstmt.setLong(1, accountId);
pstmt.setString(2, type);
pstmt.setLong(3, resourceCount);
pstmt.setLong(4, resourceCount);
pstmt.executeUpdate();
pstmt.close();
}
private static void upgradeResourceCountforDomain(Connection conn, Long domainId, String type, Long resourceCount) throws SQLException {
//update or insert into resource_count table.
PreparedStatement pstmt = null;
pstmt =
conn.prepareStatement("INSERT INTO `cloud`.`resource_count` (domain_id, type, count) VALUES (?,?,?) ON DUPLICATE KEY UPDATE id=LAST_INSERT_ID(id), count=?");
pstmt.setLong(1, domainId);
pstmt.setString(2, type);
pstmt.setLong(3, resourceCount);
pstmt.setLong(4, resourceCount);
pstmt.executeUpdate();
pstmt.close();
}
}
Reference in New Issue View Git Blame Copy Permalink