| // 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.PreparedStatement; | |
| import java.sql.ResultSet; | |
| import java.sql.SQLException; | |
| import java.sql.Types; | |
| import java.util.ArrayList; | |
| import java.util.HashMap; | |
| import java.util.List; | |
| import java.util.Map; | |
| import java.util.UUID; | |
| import org.apache.log4j.Logger; | |
| import com.cloud.offering.NetworkOffering; | |
| import com.cloud.utils.crypt.DBEncryptionUtil; | |
| import com.cloud.utils.crypt.EncryptionSecretKeyChecker; | |
| import com.cloud.utils.db.TransactionLegacy; | |
| import com.cloud.utils.exception.CloudRuntimeException; | |
| import com.cloud.utils.script.Script; | |
| public class Upgrade2214to30 extends Upgrade30xBase implements DbUpgrade { | |
| final static Logger s_logger = Logger.getLogger(Upgrade2214to30.class); | |
| @Override | |
| public String[] getUpgradableVersionRange() { | |
| return new String[] {"2.2.14", "3.0.0"}; | |
| } | |
| @Override | |
| public String getUpgradedVersion() { | |
| return "3.0.0"; | |
| } | |
| @Override | |
| public boolean supportsRollingUpgrade() { | |
| return true; | |
| } | |
| @Override | |
| public File[] getPrepareScripts() { | |
| String script = Script.findScript("", "db/schema-2214to30.sql"); | |
| if (script == null) { | |
| throw new CloudRuntimeException("Unable to find db/schema-2214to30.sql"); | |
| } | |
| return new File[] {new File(script)}; | |
| } | |
| @Override | |
| public void performDataMigration(Connection conn) { | |
| // Fail upgrade if encryption is not enabled | |
| if (!EncryptionSecretKeyChecker.useEncryption()) { | |
| throw new CloudRuntimeException("Encryption is not enabled. Please Run cloud-setup-encryption to enable encryption"); | |
| } | |
| // physical network setup | |
| setupPhysicalNetworks(conn); | |
| // encrypt data | |
| encryptData(conn); | |
| // drop keys | |
| dropKeysIfExist(conn); | |
| //update templete ID for system Vms | |
| //updateSystemVms(conn); This is not required as system template update is handled during 4.2 upgrade | |
| // update domain network ref | |
| updateDomainNetworkRef(conn); | |
| // update networks that use redundant routers to the new network offering | |
| updateReduntantRouters(conn); | |
| // update networks that have to switch from Shared to Isolated network offerings | |
| switchAccountSpecificNetworksToIsolated(conn); | |
| // update networks to external network offerings if needed | |
| String externalOfferingName = fixNetworksWithExternalDevices(conn); | |
| // create service/provider map for network offerings | |
| createNetworkOfferingServices(conn, externalOfferingName); | |
| // create service/provider map for networks | |
| createNetworkServices(conn); | |
| //migrate user concentrated deployment planner choice to new global setting | |
| migrateUserConcentratedPlannerChoice(conn); | |
| // update domain router table for element it; | |
| updateRouters(conn); | |
| //update host capacities | |
| updateHostCapacity(conn); | |
| } | |
| @Override | |
| public File[] getCleanupScripts() { | |
| String script = Script.findScript("", "db/schema-2214to30-cleanup.sql"); | |
| if (script == null) { | |
| throw new CloudRuntimeException("Unable to find db/schema-2214to30-cleanup.sql"); | |
| } | |
| return new File[] {new File(script)}; | |
| } | |
| private void setupPhysicalNetworks(Connection conn) { | |
| /** | |
| * for each zone: | |
| * add a p.network, use zone.vnet and zone.type | |
| * add default traffic types, pnsp and virtual router element in enabled state | |
| * set p.network.id in op_dc_vnet and vlan and user_ip_address | |
| * list guest networks for the zone, set p.network.id | |
| * | |
| * for cases where network_tags are used for multiple guest networks: | |
| * - figure out distinct tags | |
| * - create physical network per tag | |
| * - create traffic types and set the tag to xen_network_label | |
| * - add physical network id to networks, vlan, user_ip_address for networks belonging to this tag | |
| */ | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmtUpdate = null; | |
| try { | |
| // Load all DataCenters | |
| String xenPublicLabel = getNetworkLabelFromConfig(conn, "xen.public.network.device"); | |
| String xenPrivateLabel = getNetworkLabelFromConfig(conn, "xen.private.network.device"); | |
| String xenStorageLabel = getNetworkLabelFromConfig(conn, "xen.storage.network.device1"); | |
| String xenGuestLabel = getNetworkLabelFromConfig(conn, "xen.guest.network.device"); | |
| String kvmPublicLabel = getNetworkLabelFromConfig(conn, "kvm.public.network.device"); | |
| String kvmPrivateLabel = getNetworkLabelFromConfig(conn, "kvm.private.network.device"); | |
| String kvmGuestLabel = getNetworkLabelFromConfig(conn, "kvm.guest.network.device"); | |
| String vmwarePublicLabel = getNetworkLabelFromConfig(conn, "vmware.public.vswitch"); | |
| String vmwarePrivateLabel = getNetworkLabelFromConfig(conn, "vmware.private.vswitch"); | |
| String vmwareGuestLabel = getNetworkLabelFromConfig(conn, "vmware.guest.vswitch"); | |
| pstmt = conn.prepareStatement("SELECT id, domain_id, networktype, vnet, name, removed FROM `cloud`.`data_center`"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| while (rs.next()) { | |
| long zoneId = rs.getLong(1); | |
| Long domainId = rs.getLong(2); | |
| String networkType = rs.getString(3); | |
| String vnet = rs.getString(4); | |
| String zoneName = rs.getString(5); | |
| String removed = rs.getString(6); | |
| //set uuid for the zone | |
| String uuid = UUID.randomUUID().toString(); | |
| String updateUuid = "UPDATE `cloud`.`data_center` SET uuid = ? WHERE id = ?"; | |
| pstmtUpdate = conn.prepareStatement(updateUuid); | |
| pstmtUpdate.setString(1, uuid); | |
| pstmtUpdate.setLong(2, zoneId); | |
| pstmtUpdate.executeUpdate(); | |
| pstmtUpdate.close(); | |
| //check if public network needs to be created | |
| boolean crtPbNtwk = false; | |
| pstmt = conn.prepareStatement("SELECT * FROM `cloud`.`networks` where traffic_type=\"public\" and data_center_id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, zoneId); | |
| ResultSet rs1 = pstmt.executeQuery(); | |
| if (rs1.next()) { | |
| crtPbNtwk = true; | |
| } | |
| //check if there are multiple guest networks configured using network_tags | |
| PreparedStatement pstmt2 = | |
| conn.prepareStatement("SELECT distinct tag FROM `cloud`.`network_tags` t JOIN `cloud`.`networks` n ON t.network_id = n.id WHERE n.data_center_id = ? and n.removed IS NULL"); | |
| pstmt2Close.add(pstmt2); | |
| pstmt2.setLong(1, zoneId); | |
| ResultSet rsTags = pstmt2.executeQuery(); | |
| if (rsTags.next()) { | |
| s_logger.debug("Network tags are not empty, might have to create more than one physical network..."); | |
| //make sure setup does not use guest vnets | |
| if (vnet != null) { | |
| //check if any vnet is allocated and guest networks are using vnets. | |
| PreparedStatement pstmt4 = | |
| conn.prepareStatement("SELECT v.* FROM `cloud`.`op_dc_vnet_alloc` v JOIN `cloud`.`networks` n ON CONCAT('vlan://' , v.vnet) = " + | |
| "n.broadcast_uri WHERE v.taken IS NOT NULL AND v.data_center_id = ? AND n.removed IS NULL"); | |
| pstmt2Close.add(pstmt4); | |
| pstmt4.setLong(1, zoneId); | |
| ResultSet rsVNet = pstmt4.executeQuery(); | |
| if (rsVNet.next()) { | |
| String message = "Cannot upgrade. Your setup has multiple Physical Networks and is using guest " | |
| + "Vnet that is assigned wrongly. To upgrade, first correct the setup by doing the following: \n" | |
| + "1. Please rollback to your 2.2.14 setup\n" | |
| + "2. Please stop all VMs using isolated(virtual) networks through CloudStack\n" | |
| + "3. Run following query to find if any networks still have nics allocated:\n\t" | |
| + "a) check if any virtual guest networks still have allocated nics by running:\n\t" | |
| + "SELECT DISTINCT op.id from `cloud`.`op_networks` op JOIN `cloud`.`networks` n on " | |
| + "op.id=n.id WHERE nics_count != 0 AND guest_type = 'Virtual';\n\t" | |
| + "b) If this returns any networkd ids, then ensure that all VMs are stopped, no new VM is being started, and then shutdown management server\n\t" | |
| + "c) Clean up the nics count for the 'virtual' network id's returned in step (a) by running this:\n\t" | |
| + "UPDATE `cloud`.`op_networks` SET nics_count = 0 WHERE id = <enter id of virtual network>\n\t" | |
| + "d) Restart management server and wait for all networks to shutdown. [Networks shutdown will be " | |
| + "determined by network.gc.interval and network.gc.wait seconds] \n" | |
| + "4. Please ensure all networks are shutdown and all guest Vnet's are free.\n" | |
| + "5. Run upgrade. This will allocate all your guest vnet range to first physical network. \n" | |
| + "6. Reconfigure the vnet ranges for each physical network as desired by using updatePhysicalNetwork API \n" | |
| + "7. Start all your VMs"; | |
| s_logger.error(message); | |
| throw new CloudRuntimeException( | |
| "Cannot upgrade this setup since it uses guest vnet and will have multiple physical networks. Please check the logs for details on how to proceed"); | |
| } | |
| rsVNet.close(); | |
| //Clean up any vnets that have no live networks/nics | |
| pstmt4 = | |
| conn.prepareStatement("SELECT v.id, v.vnet, v.reservation_id FROM `cloud`.`op_dc_vnet_alloc` v LEFT JOIN networks n ON CONCAT('vlan://' , v.vnet) = n.broadcast_uri WHERE v.taken IS NOT NULL AND v.data_center_id = ? AND n.broadcast_uri IS NULL AND n.removed IS NULL"); | |
| pstmt2Close.add(pstmt4); | |
| pstmt4.setLong(1, zoneId); | |
| rsVNet = pstmt4.executeQuery(); | |
| while (rsVNet.next()) { | |
| Long vnet_id = rsVNet.getLong(1); | |
| String vnetValue = rsVNet.getString(2); | |
| String reservationId = rsVNet.getString(3); | |
| //does this vnet have any nic associated? | |
| PreparedStatement pstmt5 = conn.prepareStatement("SELECT id, instance_id FROM `cloud`.`nics` where broadcast_uri = ? and removed IS NULL"); | |
| pstmt2Close.add(pstmt5); | |
| String uri = "vlan://" + vnetValue; | |
| pstmt5.setString(1, uri); | |
| ResultSet rsNic = pstmt5.executeQuery(); | |
| Long nic_id = rsNic.getLong(1); | |
| Long instance_id = rsNic.getLong(2); | |
| if (rsNic.next()) { | |
| throw new CloudRuntimeException("Cannot upgrade. Please cleanup the guest vnet: " + vnetValue + " , it is being used by nic_id: " + | |
| nic_id + " , instance_id: " + instance_id); | |
| } | |
| //free this vnet | |
| String freeVnet = "UPDATE `cloud`.`op_dc_vnet_alloc` SET account_id = NULL, taken = NULL, reservation_id = NULL WHERE id = ?"; | |
| pstmtUpdate = conn.prepareStatement(freeVnet); | |
| pstmtUpdate.setLong(1, vnet_id); | |
| pstmtUpdate.executeUpdate(); | |
| pstmtUpdate.close(); | |
| } | |
| } | |
| boolean isFirstPhysicalNtwk = true; | |
| do { | |
| //create one physical network per tag | |
| String guestNetworkTag = rsTags.getString(1); | |
| long physicalNetworkId = addPhysicalNetworkToZone(conn, zoneId, zoneName, networkType, (isFirstPhysicalNtwk) ? vnet : null, domainId); | |
| //add Traffic types | |
| if (isFirstPhysicalNtwk) { | |
| if (crtPbNtwk) { | |
| addTrafficType(conn, physicalNetworkId, "Public", xenPublicLabel, kvmPublicLabel, vmwarePublicLabel); | |
| } else { | |
| s_logger.debug("Skip adding public traffic type to zone id=" + zoneId); | |
| } | |
| addTrafficType(conn, physicalNetworkId, "Management", xenPrivateLabel, kvmPrivateLabel, vmwarePrivateLabel); | |
| addTrafficType(conn, physicalNetworkId, "Storage", xenStorageLabel, null, null); | |
| } | |
| addTrafficType(conn, physicalNetworkId, "Guest", guestNetworkTag, kvmGuestLabel, vmwareGuestLabel); | |
| addDefaultVRProvider(conn, physicalNetworkId, zoneId); | |
| addDefaultSGProvider(conn, physicalNetworkId, zoneId, networkType, false); | |
| //for all networks with this tag, add physical_network_id | |
| PreparedStatement pstmt3 = conn.prepareStatement("SELECT network_id FROM `cloud`.`network_tags` where tag = '" + guestNetworkTag + "'"); | |
| ResultSet rsNet = pstmt3.executeQuery(); | |
| s_logger.debug("Adding PhysicalNetwork to VLAN"); | |
| s_logger.debug("Adding PhysicalNetwork to user_ip_address"); | |
| s_logger.debug("Adding PhysicalNetwork to networks"); | |
| while (rsNet.next()) { | |
| Long networkId = rsNet.getLong(1); | |
| addPhysicalNtwk_To_Ntwk_IP_Vlan(conn, physicalNetworkId, networkId); | |
| } | |
| pstmt3.close(); | |
| // add the reference to this physical network for the default public network entries in vlan / user_ip_address tables | |
| // add first physicalNetworkId to op_dc_vnet_alloc for this zone - just a placeholder since direct networking dont need this | |
| if (isFirstPhysicalNtwk) { | |
| s_logger.debug("Adding PhysicalNetwork to default Public network entries in vlan and user_ip_address"); | |
| pstmt3 = conn.prepareStatement("SELECT id FROM `cloud`.`networks` where traffic_type = 'Public' and data_center_id = " + zoneId); | |
| ResultSet rsPubNet = pstmt3.executeQuery(); | |
| if (rsPubNet.next()) { | |
| Long publicNetworkId = rsPubNet.getLong(1); | |
| addPhysicalNtwk_To_Ntwk_IP_Vlan(conn, physicalNetworkId, publicNetworkId); | |
| } | |
| pstmt3.close(); | |
| s_logger.debug("Adding PhysicalNetwork to op_dc_vnet_alloc"); | |
| String updateVnet = "UPDATE `cloud`.`op_dc_vnet_alloc` SET physical_network_id = " + physicalNetworkId + " WHERE data_center_id = " + zoneId; | |
| pstmtUpdate = conn.prepareStatement(updateVnet); | |
| pstmtUpdate.executeUpdate(); | |
| pstmtUpdate.close(); | |
| } | |
| isFirstPhysicalNtwk = false; | |
| } while (rsTags.next()); | |
| pstmt2.close(); | |
| } else { | |
| //default to one physical network | |
| long physicalNetworkId = addPhysicalNetworkToZone(conn, zoneId, zoneName, networkType, vnet, domainId); | |
| // add traffic types | |
| if (crtPbNtwk) { | |
| addTrafficType(conn, physicalNetworkId, "Public", xenPublicLabel, kvmPublicLabel, vmwarePublicLabel); | |
| } else { | |
| s_logger.debug("Skip adding public traffic type to zone id=" + zoneId); | |
| } | |
| addTrafficType(conn, physicalNetworkId, "Management", xenPrivateLabel, kvmPrivateLabel, vmwarePrivateLabel); | |
| addTrafficType(conn, physicalNetworkId, "Storage", xenStorageLabel, null, null); | |
| addTrafficType(conn, physicalNetworkId, "Guest", xenGuestLabel, kvmGuestLabel, vmwareGuestLabel); | |
| addDefaultVRProvider(conn, physicalNetworkId, zoneId); | |
| addDefaultSGProvider(conn, physicalNetworkId, zoneId, networkType, false); | |
| // add physicalNetworkId to op_dc_vnet_alloc for this zone | |
| s_logger.debug("Adding PhysicalNetwork to op_dc_vnet_alloc"); | |
| String updateVnet = "UPDATE `cloud`.`op_dc_vnet_alloc` SET physical_network_id = " + physicalNetworkId + " WHERE data_center_id = " + zoneId; | |
| pstmtUpdate = conn.prepareStatement(updateVnet); | |
| pstmtUpdate.executeUpdate(); | |
| pstmtUpdate.close(); | |
| // add physicalNetworkId to vlan for this zone | |
| s_logger.debug("Adding PhysicalNetwork to VLAN"); | |
| String updateVLAN = "UPDATE `cloud`.`vlan` SET physical_network_id = " + physicalNetworkId + " WHERE data_center_id = " + zoneId; | |
| pstmtUpdate = conn.prepareStatement(updateVLAN); | |
| pstmtUpdate.executeUpdate(); | |
| pstmtUpdate.close(); | |
| // add physicalNetworkId to user_ip_address for this zone | |
| s_logger.debug("Adding PhysicalNetwork to user_ip_address"); | |
| String updateUsrIp = "UPDATE `cloud`.`user_ip_address` SET physical_network_id = " + physicalNetworkId + " WHERE data_center_id = " + zoneId; | |
| pstmtUpdate = conn.prepareStatement(updateUsrIp); | |
| pstmtUpdate.executeUpdate(); | |
| pstmtUpdate.close(); | |
| // add physicalNetworkId to guest networks for this zone | |
| s_logger.debug("Adding PhysicalNetwork to networks"); | |
| String updateNet = | |
| "UPDATE `cloud`.`networks` SET physical_network_id = " + physicalNetworkId + " WHERE data_center_id = " + zoneId + " AND traffic_type = 'Guest'"; | |
| pstmtUpdate = conn.prepareStatement(updateNet); | |
| pstmtUpdate.executeUpdate(); | |
| pstmtUpdate.close(); | |
| //mark this physical network as removed if the zone is removed. | |
| if (removed != null) { | |
| pstmtUpdate = conn.prepareStatement("UPDATE `cloud`.`physical_network` SET removed = now() WHERE id = ?"); | |
| pstmtUpdate.setLong(1, physicalNetworkId); | |
| pstmtUpdate.executeUpdate(); | |
| pstmtUpdate.close(); | |
| } | |
| } | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Exception while adding PhysicalNetworks", e); | |
| } finally { | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| } | |
| private void encryptData(Connection conn) { | |
| s_logger.debug("Encrypting the data..."); | |
| encryptConfigValues(conn); | |
| encryptHostDetails(conn); | |
| encryptVNCPassword(conn); | |
| encryptUserCredentials(conn); | |
| encryptVPNPassword(conn); | |
| s_logger.debug("Done encrypting the data"); | |
| } | |
| private void encryptConfigValues(Connection conn) { | |
| s_logger.debug("Encrypting Config values"); | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| try { | |
| pstmt = conn.prepareStatement("select name, value from `cloud`.`configuration` where category in ('Hidden', 'Secure')"); | |
| rs = pstmt.executeQuery(); | |
| while (rs.next()) { | |
| String name = rs.getString(1); | |
| String value = rs.getString(2); | |
| if (value == null) { | |
| continue; | |
| } | |
| String encryptedValue = DBEncryptionUtil.encrypt(value); | |
| pstmt = conn.prepareStatement("update `cloud`.`configuration` set value=? where name=?"); | |
| pstmt.setBytes(1, encryptedValue.getBytes("UTF-8")); | |
| pstmt.setString(2, name); | |
| pstmt.executeUpdate(); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable encrypt configuration values ", e); | |
| } catch (UnsupportedEncodingException e) { | |
| throw new CloudRuntimeException("Unable encrypt configuration values ", e); | |
| } finally { | |
| try { | |
| if (rs != null) { | |
| rs.close(); | |
| } | |
| if (pstmt != null) { | |
| pstmt.close(); | |
| } | |
| } catch (SQLException e) { | |
| } | |
| } | |
| s_logger.debug("Done encrypting Config values"); | |
| } | |
| private void encryptHostDetails(Connection conn) { | |
| s_logger.debug("Encrypting host details"); | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| try { | |
| pstmt = conn.prepareStatement("select id, value from `cloud`.`host_details` where name = 'password'"); | |
| pstmt2Close.add(pstmt); | |
| 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`.`host_details` set value=? where id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setBytes(1, encryptedValue.getBytes("UTF-8")); | |
| pstmt.setLong(2, id); | |
| pstmt.executeUpdate(); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable encrypt host_details values ", e); | |
| } catch (UnsupportedEncodingException e) { | |
| throw new CloudRuntimeException("Unable encrypt host_details values ", e); | |
| } finally { | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| s_logger.debug("Done encrypting host details"); | |
| } | |
| private void encryptVNCPassword(Connection conn) { | |
| s_logger.debug("Encrypting vm_instance vnc_password"); | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| try { | |
| int numRows = 0; | |
| pstmt = conn.prepareStatement("select count(id) from `cloud`.`vm_instance`"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| if (rs.next()) { | |
| numRows = rs.getInt(1); | |
| } | |
| rs.close(); | |
| pstmt.close(); | |
| int offset = 0; | |
| while (offset < numRows) { | |
| pstmt = conn.prepareStatement("select id, vnc_password from `cloud`.`vm_instance` limit " + offset + ", 500"); | |
| pstmt2Close.add(pstmt); | |
| 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`.`vm_instance` set vnc_password=? where id=?"); | |
| pstmt.setBytes(1, encryptedValue.getBytes("UTF-8")); | |
| pstmt.setLong(2, id); | |
| pstmt.executeUpdate(); | |
| pstmt.close(); | |
| } | |
| rs.close(); | |
| offset += 500; | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable encrypt vm_instance vnc_password ", e); | |
| } catch (UnsupportedEncodingException e) { | |
| throw new CloudRuntimeException("Unable encrypt vm_instance vnc_password ", e); | |
| } finally { | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| s_logger.debug("Done encrypting vm_instance vnc_password"); | |
| } | |
| private void encryptUserCredentials(Connection conn) { | |
| s_logger.debug("Encrypting user keys"); | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| try { | |
| pstmt = conn.prepareStatement("select id, secret_key from `cloud`.`user`"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| while (rs.next()) { | |
| long id = rs.getLong(1); | |
| String secretKey = rs.getString(2); | |
| String encryptedSecretKey = DBEncryptionUtil.encrypt(secretKey); | |
| pstmt = conn.prepareStatement("update `cloud`.`user` set secret_key=? where id=?"); | |
| pstmt2Close.add(pstmt); | |
| if (encryptedSecretKey == null) { | |
| pstmt.setNull(1, Types.VARCHAR); | |
| } else { | |
| pstmt.setBytes(1, encryptedSecretKey.getBytes("UTF-8")); | |
| } | |
| pstmt.setLong(2, id); | |
| pstmt.executeUpdate(); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable encrypt user secret key ", e); | |
| } catch (UnsupportedEncodingException e) { | |
| throw new CloudRuntimeException("Unable encrypt user secret key ", e); | |
| } finally { | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| s_logger.debug("Done encrypting user keys"); | |
| } | |
| private void encryptVPNPassword(Connection conn) { | |
| s_logger.debug("Encrypting vpn_users password"); | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| try { | |
| pstmt = conn.prepareStatement("select id, password from `cloud`.`vpn_users`"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| while (rs.next()) { | |
| long id = rs.getLong(1); | |
| String password = rs.getString(2); | |
| String encryptedpassword = DBEncryptionUtil.encrypt(password); | |
| pstmt = conn.prepareStatement("update `cloud`.`vpn_users` set password=? where id=?"); | |
| pstmt2Close.add(pstmt); | |
| if (encryptedpassword == null) { | |
| pstmt.setNull(1, Types.VARCHAR); | |
| } else { | |
| pstmt.setBytes(1, encryptedpassword.getBytes("UTF-8")); | |
| } | |
| pstmt.setLong(2, id); | |
| pstmt.executeUpdate(); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable encrypt vpn_users password ", e); | |
| } catch (UnsupportedEncodingException e) { | |
| throw new CloudRuntimeException("Unable encrypt vpn_users password ", e); | |
| } finally { | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| s_logger.debug("Done encrypting vpn_users password"); | |
| } | |
| private void dropKeysIfExist(Connection conn) { | |
| HashMap<String, List<String>> uniqueKeys = new HashMap<String, List<String>>(); | |
| List<String> keys = new ArrayList<String>(); | |
| keys.add("public_ip_address"); | |
| uniqueKeys.put("console_proxy", keys); | |
| uniqueKeys.put("secondary_storage_vm", keys); | |
| // drop keys | |
| s_logger.debug("Dropping public_ip_address keys from `cloud`.`secondary_storage_vm` and console_proxy tables..."); | |
| for (String tableName : uniqueKeys.keySet()) { | |
| DbUpgradeUtils.dropKeysIfExist(conn, tableName, uniqueKeys.get(tableName), false); | |
| } | |
| } | |
| private void createNetworkOfferingServices(Connection conn, String externalOfferingName) { | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| try { | |
| pstmt = | |
| conn.prepareStatement("select id, dns_service, gateway_service, firewall_service, lb_service, userdata_service," | |
| + " vpn_service, dhcp_service, unique_name from `cloud`.`network_offerings` where traffic_type='Guest'"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| while (rs.next()) { | |
| boolean sharedSourceNat = false; | |
| boolean dedicatedLb = true; | |
| long id = rs.getLong(1); | |
| String uniqueName = rs.getString(9); | |
| Map<String, String> services = new HashMap<String, String>(); | |
| if (rs.getLong(2) != 0) { | |
| services.put("Dns", "VirtualRouter"); | |
| } | |
| if (rs.getLong(3) != 0) { | |
| if (externalOfferingName != null && uniqueName.equalsIgnoreCase(externalOfferingName)) { | |
| services.put("Gateway", "JuniperSRX"); | |
| } else { | |
| services.put("Gateway", "VirtualRouter"); | |
| } | |
| } | |
| if (rs.getLong(4) != 0) { | |
| if (externalOfferingName != null && uniqueName.equalsIgnoreCase(externalOfferingName)) { | |
| services.put("Firewall", "JuniperSRX"); | |
| } else { | |
| services.put("Firewall", "VirtualRouter"); | |
| } | |
| } | |
| if (rs.getLong(5) != 0) { | |
| if (externalOfferingName != null && uniqueName.equalsIgnoreCase(externalOfferingName)) { | |
| services.put("Lb", "F5BigIp"); | |
| dedicatedLb = false; | |
| } else { | |
| services.put("Lb", "VirtualRouter"); | |
| } | |
| } | |
| if (rs.getLong(6) != 0) { | |
| services.put("UserData", "VirtualRouter"); | |
| } | |
| if (rs.getLong(7) != 0) { | |
| if (externalOfferingName == null || !uniqueName.equalsIgnoreCase(externalOfferingName)) { | |
| services.put("Vpn", "VirtualRouter"); | |
| } | |
| } | |
| if (rs.getLong(8) != 0) { | |
| services.put("Dhcp", "VirtualRouter"); | |
| } | |
| if (uniqueName.equalsIgnoreCase(NetworkOffering.DefaultSharedNetworkOfferingWithSGService.toString())) { | |
| services.put("SecurityGroup", "SecurityGroupProvider"); | |
| } | |
| if (uniqueName.equals(NetworkOffering.DefaultIsolatedNetworkOfferingWithSourceNatService.toString()) || | |
| uniqueName.equals(NetworkOffering.DefaultIsolatedNetworkOfferingWithSourceNatService.toString() + "-redundant") || | |
| uniqueName.equalsIgnoreCase(externalOfferingName)) { | |
| if (externalOfferingName != null && uniqueName.equalsIgnoreCase(externalOfferingName)) { | |
| services.put("SourceNat", "JuniperSRX"); | |
| services.put("PortForwarding", "JuniperSRX"); | |
| services.put("StaticNat", "JuniperSRX"); | |
| sharedSourceNat = true; | |
| } else { | |
| services.put("SourceNat", "VirtualRouter"); | |
| services.put("PortForwarding", "VirtualRouter"); | |
| services.put("StaticNat", "VirtualRouter"); | |
| } | |
| } | |
| for (String service : services.keySet()) { | |
| pstmt = | |
| conn.prepareStatement("INSERT INTO `cloud`.`ntwk_offering_service_map` (`network_offering_id`," | |
| + " `service`, `provider`, `created`) values (?,?,?, now())"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, id); | |
| pstmt.setString(2, service); | |
| pstmt.setString(3, services.get(service)); | |
| pstmt.executeUpdate(); | |
| } | |
| //update shared source nat and dedicated lb | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`network_offerings` set shared_source_nat_service=?, dedicated_lb_service=? where id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setBoolean(1, sharedSourceNat); | |
| pstmt.setBoolean(2, dedicatedLb); | |
| pstmt.setLong(3, id); | |
| pstmt.executeUpdate(); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable to create service/provider map for network offerings", e); | |
| } finally { | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| } | |
| private void updateDomainNetworkRef(Connection conn) { | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| try { | |
| // update subdomain access field for existing domain specific networks | |
| pstmt = conn.prepareStatement("select value from `cloud`.`configuration` where name='allow.subdomain.network.access'"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| while (rs.next()) { | |
| boolean subdomainAccess = Boolean.valueOf(rs.getString(1)); | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`domain_network_ref` SET subdomain_access=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setBoolean(1, subdomainAccess); | |
| pstmt.executeUpdate(); | |
| s_logger.debug("Successfully updated subdomain_access field in network_domain table with value " + subdomainAccess); | |
| } | |
| // convert zone level 2.2.x networks to ROOT domain 3.0 access networks | |
| pstmt = conn.prepareStatement("select id from `cloud`.`networks` where shared=true and is_domain_specific=false and traffic_type='Guest'"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| while (rs.next()) { | |
| long networkId = rs.getLong(1); | |
| pstmt = conn.prepareStatement("INSERT INTO `cloud`.`domain_network_ref` (domain_id, network_id, subdomain_access) VALUES (1, ?, 1)"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, networkId); | |
| pstmt.executeUpdate(); | |
| s_logger.debug("Successfully converted zone specific network id=" + networkId + " to the ROOT domain level network with subdomain access set to true"); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable to update domain network ref", e); | |
| } finally { | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| } | |
| protected void createNetworkServices(Connection conn) { | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| ResultSet networkRs = null; | |
| ResultSet offeringRs = null; | |
| try { | |
| pstmt = conn.prepareStatement("select id, network_offering_id from `cloud`.`networks` where traffic_type='Guest'"); | |
| pstmt2Close.add(pstmt); | |
| networkRs = pstmt.executeQuery(); | |
| while (networkRs.next()) { | |
| long networkId = networkRs.getLong(1); | |
| long networkOfferingId = networkRs.getLong(2); | |
| pstmt = conn.prepareStatement("select service, provider from `cloud`.`ntwk_offering_service_map` where network_offering_id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, networkOfferingId); | |
| offeringRs = pstmt.executeQuery(); | |
| while (offeringRs.next()) { | |
| String service = offeringRs.getString(1); | |
| String provider = offeringRs.getString(2); | |
| pstmt = conn.prepareStatement("INSERT INTO `cloud`.`ntwk_service_map` (`network_id`, `service`, `provider`, `created`) values (?,?,?, now())"); | |
| pstmt.setLong(1, networkId); | |
| pstmt.setString(2, service); | |
| pstmt.setString(3, provider); | |
| pstmt.executeUpdate(); | |
| } | |
| s_logger.debug("Created service/provider map for network id=" + networkId); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable to create service/provider map for networks", e); | |
| } finally { | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| } | |
| protected void updateRouters(Connection conn) { | |
| PreparedStatement pstmt = null; | |
| try { | |
| s_logger.debug("Updating domain_router table"); | |
| pstmt = | |
| conn.prepareStatement("UPDATE domain_router, virtual_router_providers vrp LEFT JOIN (physical_network_service_providers pnsp INNER JOIN physical_network pntwk INNER JOIN vm_instance vm INNER JOIN domain_router vr) ON (vrp.nsp_id = pnsp.id AND pnsp.physical_network_id = pntwk.id AND pntwk.data_center_id = vm.data_center_id AND vm.id=vr.id) SET vr.element_id=vrp.id;"); | |
| pstmt.executeUpdate(); | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable to update router table. ", e); | |
| } finally { | |
| try { | |
| if (pstmt != null) { | |
| pstmt.close(); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable to close statement for router table. ", e); | |
| } | |
| } | |
| } | |
| protected void updateReduntantRouters(Connection conn) { | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| ResultSet rs1 = null; | |
| try { | |
| // get all networks that need to be updated to the redundant network offerings | |
| pstmt = | |
| conn.prepareStatement("select ni.network_id, n.network_offering_id from `cloud`.`nics` ni, `cloud`.`networks` n where ni.instance_id in (select id from `cloud`.`domain_router` where is_redundant_router=1) and n.id=ni.network_id and n.traffic_type='Guest'"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| pstmt = conn.prepareStatement("select count(*) from `cloud`.`network_offerings`"); | |
| pstmt2Close.add(pstmt); | |
| rs1 = pstmt.executeQuery(); | |
| long ntwkOffCount = 0; | |
| while (rs1.next()) { | |
| ntwkOffCount = rs1.getLong(1); | |
| } | |
| s_logger.debug("Have " + ntwkOffCount + " networkOfferings"); | |
| pstmt = conn.prepareStatement("CREATE TEMPORARY TABLE `cloud`.`network_offerings2` ENGINE=MEMORY SELECT * FROM `cloud`.`network_offerings` WHERE id=1"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| HashMap<Long, Long> newNetworkOfferingMap = new HashMap<Long, Long>(); | |
| while (rs.next()) { | |
| long networkId = rs.getLong(1); | |
| long networkOfferingId = rs.getLong(2); | |
| s_logger.debug("Updating network offering for the network id=" + networkId + " as it has redundant routers"); | |
| Long newNetworkOfferingId = null; | |
| if (!newNetworkOfferingMap.containsKey(networkOfferingId)) { | |
| // clone the record to | |
| pstmt = conn.prepareStatement("INSERT INTO `cloud`.`network_offerings2` SELECT * FROM `cloud`.`network_offerings` WHERE id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, networkOfferingId); | |
| pstmt.executeUpdate(); | |
| pstmt = conn.prepareStatement("SELECT unique_name FROM `cloud`.`network_offerings` WHERE id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, networkOfferingId); | |
| rs1 = pstmt.executeQuery(); | |
| String uniqueName = null; | |
| while (rs1.next()) { | |
| uniqueName = rs1.getString(1) + "-redundant"; | |
| } | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`network_offerings2` SET id=?, redundant_router_service=1, unique_name=?, name=? WHERE id=?"); | |
| pstmt2Close.add(pstmt); | |
| ntwkOffCount = ntwkOffCount + 1; | |
| newNetworkOfferingId = ntwkOffCount; | |
| pstmt.setLong(1, newNetworkOfferingId); | |
| pstmt.setString(2, uniqueName); | |
| pstmt.setString(3, uniqueName); | |
| pstmt.setLong(4, networkOfferingId); | |
| pstmt.executeUpdate(); | |
| pstmt = conn.prepareStatement("INSERT INTO `cloud`.`network_offerings` SELECT * from `cloud`.`network_offerings2` WHERE id=" + newNetworkOfferingId); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`networks` SET network_offering_id=? where id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, newNetworkOfferingId); | |
| pstmt.setLong(2, networkId); | |
| pstmt.executeUpdate(); | |
| newNetworkOfferingMap.put(networkOfferingId, ntwkOffCount); | |
| } else { | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`networks` SET network_offering_id=? where id=?"); | |
| pstmt2Close.add(pstmt); | |
| newNetworkOfferingId = newNetworkOfferingMap.get(networkOfferingId); | |
| pstmt.setLong(1, newNetworkOfferingId); | |
| pstmt.setLong(2, networkId); | |
| pstmt.executeUpdate(); | |
| } | |
| s_logger.debug("Successfully updated network offering id=" + networkId + " with new network offering id " + newNetworkOfferingId); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable to update redundant router networks", e); | |
| } finally { | |
| try { | |
| pstmt = conn.prepareStatement("DROP TABLE `cloud`.`network_offerings2`"); | |
| pstmt.executeUpdate(); | |
| pstmt.close(); | |
| } catch (SQLException e) { | |
| } | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| } | |
| protected void updateHostCapacity(Connection conn) { | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| try { | |
| s_logger.debug("Updating op_host_capacity table, column capacity_state"); | |
| pstmt = | |
| conn.prepareStatement("UPDATE op_host_capacity, host SET op_host_capacity.capacity_state='Disabled' where host.id=op_host_capacity.host_id and op_host_capacity.capacity_type in (0,1) and host.resource_state='Disabled';"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| pstmt = | |
| conn.prepareStatement("UPDATE op_host_capacity, cluster SET op_host_capacity.capacity_state='Disabled' where cluster.id=op_host_capacity.cluster_id and cluster.allocation_state='Disabled';"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| pstmt = | |
| conn.prepareStatement("UPDATE op_host_capacity, host_pod_ref SET op_host_capacity.capacity_state='Disabled' where host_pod_ref.id=op_host_capacity.pod_id and host_pod_ref.allocation_state='Disabled';"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| pstmt = | |
| conn.prepareStatement("UPDATE op_host_capacity, data_center SET op_host_capacity.capacity_state='Disabled' where data_center.id=op_host_capacity.data_center_id and data_center.allocation_state='Disabled';"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable to update op_host_capacity table. ", e); | |
| } finally { | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| } | |
| protected void switchAccountSpecificNetworksToIsolated(Connection conn) { | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| ResultSet rs1 = null; | |
| try { | |
| //check if switch_to_isolated is present; if not - skip this part of the code | |
| try { | |
| pstmt = conn.prepareStatement("select switch_to_isolated from `cloud`.`networks`"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| } catch (Exception ex) { | |
| s_logger.debug("switch_to_isolated field is not present in networks table"); | |
| if (pstmt != null) { | |
| pstmt.close(); | |
| } | |
| return; | |
| } | |
| // get all networks that need to be updated to the isolated network offering | |
| pstmt = conn.prepareStatement("select id, network_offering_id from `cloud`.`networks` where switch_to_isolated=1"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| pstmt = conn.prepareStatement("select count(*) from `cloud`.`network_offerings`"); | |
| pstmt2Close.add(pstmt); | |
| rs1 = pstmt.executeQuery(); | |
| long ntwkOffCount = 0; | |
| while (rs1.next()) { | |
| ntwkOffCount = rs1.getLong(1); | |
| } | |
| s_logger.debug("Have " + ntwkOffCount + " networkOfferings"); | |
| pstmt = conn.prepareStatement("CREATE TEMPORARY TABLE `cloud`.`network_offerings2` ENGINE=MEMORY SELECT * FROM `cloud`.`network_offerings` WHERE id=1"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| HashMap<Long, Long> newNetworkOfferingMap = new HashMap<Long, Long>(); | |
| while (rs.next()) { | |
| long networkId = rs.getLong(1); | |
| long networkOfferingId = rs.getLong(2); | |
| s_logger.debug("Updating network offering for the network id=" + networkId + " as it has switch_to_isolated=1"); | |
| Long newNetworkOfferingId = null; | |
| if (!newNetworkOfferingMap.containsKey(networkOfferingId)) { | |
| // clone the record to | |
| pstmt = conn.prepareStatement("INSERT INTO `cloud`.`network_offerings2` SELECT * FROM `cloud`.`network_offerings` WHERE id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, networkOfferingId); | |
| pstmt.executeUpdate(); | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`network_offerings2` SET id=?, guest_type='Isolated', unique_name=?, name=? WHERE id=?"); | |
| pstmt2Close.add(pstmt); | |
| ntwkOffCount = ntwkOffCount + 1; | |
| newNetworkOfferingId = ntwkOffCount; | |
| String uniqueName = "Isolated w/o source nat"; | |
| pstmt.setLong(1, newNetworkOfferingId); | |
| pstmt.setString(2, uniqueName); | |
| pstmt.setString(3, uniqueName); | |
| pstmt.setLong(4, networkOfferingId); | |
| pstmt.executeUpdate(); | |
| pstmt = conn.prepareStatement("INSERT INTO `cloud`.`network_offerings` SELECT * from `cloud`.`network_offerings2` WHERE id=" + newNetworkOfferingId); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`networks` SET network_offering_id=? where id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, newNetworkOfferingId); | |
| pstmt.setLong(2, networkId); | |
| pstmt.executeUpdate(); | |
| newNetworkOfferingMap.put(networkOfferingId, ntwkOffCount); | |
| } else { | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`networks` SET network_offering_id=? where id=?"); | |
| pstmt2Close.add(pstmt); | |
| newNetworkOfferingId = newNetworkOfferingMap.get(networkOfferingId); | |
| pstmt.setLong(1, newNetworkOfferingId); | |
| pstmt.setLong(2, networkId); | |
| pstmt.executeUpdate(); | |
| } | |
| s_logger.debug("Successfully updated network offering id=" + networkId + " with new network offering id " + newNetworkOfferingId); | |
| } | |
| try { | |
| pstmt = conn.prepareStatement("ALTER TABLE `cloud`.`networks` DROP COLUMN `switch_to_isolated`"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| } catch (Exception ex) { | |
| // do nothing here | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable to switch networks to isolated", e); | |
| } finally { | |
| try { | |
| pstmt = conn.prepareStatement("DROP TABLE `cloud`.`network_offerings2`"); | |
| pstmt.executeUpdate(); | |
| pstmt.close(); | |
| } catch (SQLException e) { | |
| } | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| } | |
| private void migrateUserConcentratedPlannerChoice(Connection conn) { | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| try { | |
| pstmt = conn.prepareStatement("SELECT value FROM `cloud`.`configuration` where name = 'use.user.concentrated.pod.allocation'"); | |
| rs = pstmt.executeQuery(); | |
| Boolean isuserconcentrated = false; | |
| if (rs.next()) { | |
| String value = rs.getString(1); | |
| isuserconcentrated = new Boolean(value); | |
| } | |
| rs.close(); | |
| pstmt.close(); | |
| if (isuserconcentrated) { | |
| String currentAllocationAlgo = "random"; | |
| pstmt = conn.prepareStatement("SELECT value FROM `cloud`.`configuration` where name = 'vm.allocation.algorithm'"); | |
| rs = pstmt.executeQuery(); | |
| if (rs.next()) { | |
| currentAllocationAlgo = rs.getString(1); | |
| } | |
| rs.close(); | |
| pstmt.close(); | |
| String newAllocAlgo = "userconcentratedpod_random"; | |
| if ("random".equalsIgnoreCase(currentAllocationAlgo)) { | |
| newAllocAlgo = "userconcentratedpod_random"; | |
| } else { | |
| newAllocAlgo = "userconcentratedpod_firstfit"; | |
| } | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`configuration` SET value = ? WHERE name = 'vm.allocation.algorithm'"); | |
| pstmt.setString(1, newAllocAlgo); | |
| pstmt.executeUpdate(); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable to migrate the user_concentrated planner choice", e); | |
| } finally { | |
| try { | |
| if (rs != null) { | |
| rs.close(); | |
| } | |
| if (pstmt != null) { | |
| pstmt.close(); | |
| } | |
| } catch (SQLException e) { | |
| } | |
| } | |
| } | |
| protected String fixNetworksWithExternalDevices(Connection conn) { | |
| List<PreparedStatement> pstmt2Close = new ArrayList<PreparedStatement>(); | |
| PreparedStatement pstmt = null; | |
| ResultSet rs = null; | |
| ResultSet rs1 = null; | |
| //Get zones to upgrade | |
| List<Long> zoneIds = new ArrayList<Long>(); | |
| try { | |
| pstmt = | |
| conn.prepareStatement("select id from `cloud`.`data_center` where lb_provider='F5BigIp' or firewall_provider='JuniperSRX' or gateway_provider='JuniperSRX'"); | |
| pstmt2Close.add(pstmt); | |
| rs = pstmt.executeQuery(); | |
| while (rs.next()) { | |
| zoneIds.add(rs.getLong(1)); | |
| } | |
| } catch (SQLException e) { | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| throw new CloudRuntimeException("Unable to switch networks to the new network offering", e); | |
| } | |
| String uniqueName = null; | |
| HashMap<Long, Long> newNetworkOfferingMap = new HashMap<Long, Long>(); | |
| for (Long zoneId : zoneIds) { | |
| try { | |
| // Find the correct network offering | |
| pstmt = conn.prepareStatement("select id, network_offering_id from `cloud`.`networks` where guest_type='Virtual' and data_center_id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, zoneId); | |
| rs = pstmt.executeQuery(); | |
| pstmt = conn.prepareStatement("select count(*) from `cloud`.`network_offerings`"); | |
| rs1 = pstmt.executeQuery(); | |
| long ntwkOffCount = 0; | |
| while (rs1.next()) { | |
| ntwkOffCount = rs1.getLong(1); | |
| } | |
| pstmt = conn.prepareStatement("CREATE TEMPORARY TABLE `cloud`.`network_offerings2` ENGINE=MEMORY SELECT * FROM `cloud`.`network_offerings` WHERE id=1"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| while (rs.next()) { | |
| long networkId = rs.getLong(1); | |
| long networkOfferingId = rs.getLong(2); | |
| s_logger.debug("Updating network offering for the network id=" + networkId + " as it has switch_to_isolated=1"); | |
| Long newNetworkOfferingId = null; | |
| if (!newNetworkOfferingMap.containsKey(networkOfferingId)) { | |
| uniqueName = "Isolated with external providers"; | |
| // clone the record to | |
| pstmt = conn.prepareStatement("INSERT INTO `cloud`.`network_offerings2` SELECT * FROM `cloud`.`network_offerings` WHERE id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, networkOfferingId); | |
| pstmt.executeUpdate(); | |
| //set the new unique name | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`network_offerings2` SET id=?, unique_name=?, name=? WHERE id=?"); | |
| pstmt2Close.add(pstmt); | |
| ntwkOffCount = ntwkOffCount + 1; | |
| newNetworkOfferingId = ntwkOffCount; | |
| pstmt.setLong(1, newNetworkOfferingId); | |
| pstmt.setString(2, uniqueName); | |
| pstmt.setString(3, uniqueName); | |
| pstmt.setLong(4, networkOfferingId); | |
| pstmt.executeUpdate(); | |
| pstmt = | |
| conn.prepareStatement("INSERT INTO `cloud`.`network_offerings` SELECT * from " + "`cloud`.`network_offerings2` WHERE id=" + | |
| newNetworkOfferingId); | |
| pstmt2Close.add(pstmt); | |
| pstmt.executeUpdate(); | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`networks` SET network_offering_id=? where id=?"); | |
| pstmt2Close.add(pstmt); | |
| pstmt.setLong(1, newNetworkOfferingId); | |
| pstmt.setLong(2, networkId); | |
| pstmt.executeUpdate(); | |
| newNetworkOfferingMap.put(networkOfferingId, ntwkOffCount); | |
| } else { | |
| pstmt = conn.prepareStatement("UPDATE `cloud`.`networks` SET network_offering_id=? where id=?"); | |
| pstmt2Close.add(pstmt); | |
| newNetworkOfferingId = newNetworkOfferingMap.get(networkOfferingId); | |
| pstmt.setLong(1, newNetworkOfferingId); | |
| pstmt.setLong(2, networkId); | |
| pstmt.executeUpdate(); | |
| } | |
| s_logger.debug("Successfully updated network id=" + networkId + " with new network offering id " + newNetworkOfferingId); | |
| } | |
| } catch (SQLException e) { | |
| throw new CloudRuntimeException("Unable to switch networks to the new network offering", e); | |
| } finally { | |
| try { | |
| pstmt = conn.prepareStatement("DROP TABLE `cloud`.`network_offerings2`"); | |
| pstmt.executeUpdate(); | |
| pstmt.close(); | |
| } catch (SQLException e) { | |
| } | |
| TransactionLegacy.closePstmts(pstmt2Close); | |
| } | |
| } | |
| return uniqueName; | |
| } | |
| } |