Java tutorial
/** * Copyright (C) 2010 Cloud.com, Inc. All rights reserved. * * This software is licensed under the GNU General Public License v3 or later. * * It is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or any later version. * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. * */ package com.cloud.migration; import java.io.File; import java.io.FileInputStream; import java.io.IOException; import java.net.NetworkInterface; import java.net.SocketException; import java.security.NoSuchAlgorithmException; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.List; import java.util.NoSuchElementException; import java.util.Properties; import java.util.Random; import java.util.Scanner; import javax.crypto.KeyGenerator; import javax.crypto.SecretKey; import org.apache.commons.codec.binary.Base64; import org.apache.log4j.Logger; import org.apache.log4j.xml.DOMConfigurator; import com.cloud.configuration.Config; import com.cloud.configuration.ConfigurationVO; import com.cloud.configuration.dao.ConfigurationDao; import com.cloud.consoleproxy.ConsoleProxyManager; import com.cloud.dc.ClusterVO; import com.cloud.dc.DataCenterVO; import com.cloud.dc.HostPodVO; import com.cloud.dc.dao.ClusterDao; import com.cloud.dc.dao.DataCenterDao; import com.cloud.dc.dao.HostPodDao; import com.cloud.domain.DomainVO; import com.cloud.domain.dao.DomainDao; import com.cloud.host.Host; import com.cloud.host.HostVO; import com.cloud.host.dao.HostDao; import com.cloud.migration.DiskOffering21VO.Type; import com.cloud.storage.Storage.StoragePoolType; import com.cloud.storage.StoragePoolVO; import com.cloud.storage.Volume; import com.cloud.storage.VolumeVO; import com.cloud.storage.dao.StoragePoolDao; import com.cloud.storage.dao.VolumeDao; import com.cloud.storage.secondary.SecondaryStorageVmManager; import com.cloud.utils.NumbersUtil; import com.cloud.utils.PropertiesUtil; import com.cloud.utils.component.ComponentLocator; import com.cloud.utils.db.Filter; import com.cloud.utils.db.GenericSearchBuilder; import com.cloud.utils.db.SearchBuilder; import com.cloud.utils.db.SearchCriteria; import com.cloud.utils.db.SearchCriteria.Func; import com.cloud.utils.db.SearchCriteria.Op; import com.cloud.utils.db.Transaction; import com.cloud.utils.net.NetUtils; import com.cloud.utils.script.Script; import com.cloud.vm.ConsoleProxyVO; import com.cloud.vm.DomainRouterVO; import com.cloud.vm.SecondaryStorageVmVO; import com.cloud.vm.UserVmVO; import com.cloud.vm.VMInstanceVO; import com.cloud.vm.VirtualMachine; import com.cloud.vm.VirtualMachine.State; import com.cloud.vm.dao.ConsoleProxyDao; import com.cloud.vm.dao.DomainRouterDao; import com.cloud.vm.dao.SecondaryStorageVmDao; import com.cloud.vm.dao.UserVmDao; import com.cloud.vm.dao.VMInstanceDao; public class Db20to21MigrationUtil { private static final Logger s_logger = Logger.getLogger(Db20to21MigrationUtil.class); protected DataCenterDao _dcDao; protected HostPodDao _podDao; protected ConfigurationDao _configDao; protected ClusterDao _clusterDao; protected HostDao _hostDao; protected StoragePoolDao _spDao; protected DomainDao _domainDao; protected ServiceOffering20Dao _serviceOffering20Dao; protected DiskOffering20Dao _diskOffering20Dao; protected ServiceOffering21Dao _serviceOffering21Dao; protected DiskOffering21Dao _diskOffering21Dao; protected ConsoleProxyDao _consoleProxyDao; protected SecondaryStorageVmDao _secStorageVmDao; protected VMInstanceDao _vmInstanceDao; protected VolumeDao _volumeDao; protected UserVmDao _userVmDao; protected DomainRouterDao _routerDao; protected StoragePoolDao _poolDao; protected long _consoleProxyServiceOfferingId; protected long _secStorageServiceOfferingId; protected long _domRServiceOfferingId; protected boolean _isPremium = false; protected static class DcPod { long id; String name; long count; public DcPod() { } } private void migrateZones() { boolean createCluster = false; String value = _configDao.getValue("xen.create.pools.in.pod"); if (value == null || !value.equalsIgnoreCase("true")) { s_logger.info( "System is not configured to use Xen server pool, we will skip creating cluster for pods"); } else { createCluster = true; } // Displaying summarize data center/pod configuration from old DB before we continue GenericSearchBuilder<DataCenterVO, DcPod> sb = _dcDao.createSearchBuilder(DcPod.class); sb.selectField(sb.entity().getId()); sb.selectField(sb.entity().getName()); sb.select("count", Func.COUNT, null); sb.groupBy(sb.entity().getId(), sb.entity().getName()); sb.done(); SearchCriteria<DcPod> sc = sb.create(); List<DcPod> results = _dcDao.customSearchIncludingRemoved(sc, (Filter) null); if (results.size() > 0) { System.out.println("We've found following zones are deployed in your database"); for (DcPod cols : results) { System.out.println("\tid: " + cols.id + ",\tname: " + cols.name + ",\tpods in zone: " + cols.count); } System.out.println("From 2.0 to 2.1, pod is required to have gateway configuration"); for (DcPod cols : results) { migrateZonePods(cols.id, cols.name, createCluster); s_logger.info("Set system VM guest MAC in zone" + cols.name); migrateSystemVmGuestMacAndState(cols.id); } } else { System.out.println("We couldn't find any zone being deployed. Skip Zone/Pod migration"); } } private void migrateZonePods(long zoneId, String zoneName, boolean createCluster) { SearchBuilder<HostPodVO> sb = _podDao.createSearchBuilder(); sb.and("zoneId", sb.entity().getDataCenterId(), Op.EQ); sb.done(); SearchCriteria<HostPodVO> sc = sb.create(); sc.setParameters("zoneId", zoneId); List<HostPodVO> pods = _podDao.searchIncludingRemoved(sc, null, false, false); if (pods.size() > 0) { for (HostPodVO pod : pods) { System.out.println("Migrating pod " + pod.getName() + " in zone " + zoneName + "..."); System.out.println("Current pod " + pod.getName() + " configuration as"); System.out.println("\tCIDR: " + pod.getCidrAddress() + "/" + pod.getCidrSize()); System.out.println("\tGateway: " + pod.getGateway()); System.out.print("Please type your gateway address for the pod: "); String gateway = readInput(); pod.setGateway(gateway); _podDao.update(pod.getId(), pod); if (createCluster) { migrateHostsInPod(zoneId, pod.getId(), pod.getName()); } System.out.println("Set last_host_id for VMs in pod " + pod.getName()); migrateVmInstanceLastHostId(zoneId, pod.getId()); System.out.println("Setup link local addresses, it will take a while, please wait..."); String ipNums = _configDao.getValue("linkLocalIp.nums"); int nums = Integer.parseInt(ipNums); if (nums > 16 || nums <= 0) { nums = 10; } /*local link ip address starts from 169.254.0.2 - 169.254.(nums)*/ String[] ipRanges = NetUtils.getLinkLocalIPRange(nums); _dcDao.addLinkLocalIpAddress(zoneId, pod.getId(), ipRanges[0], ipRanges[1]); } } } private void migrateHostsInPod(long zoneId, long podId, String podName) { System.out.println("Creating cluster for pod " + podName); ClusterVO cluster = null; SearchBuilder<HostVO> sb = _hostDao.createSearchBuilder(); sb.and("dc", sb.entity().getDataCenterId(), Op.EQ); sb.and("pod", sb.entity().getPodId(), Op.EQ); sb.and("type", sb.entity().getType(), Op.EQ); sb.done(); SearchCriteria<HostVO> sc = sb.create(); sc.setParameters("dc", zoneId); sc.setParameters("pod", podId); sc.setParameters("type", Host.Type.Routing); // join cluster for hosts in pod List<HostVO> hostsInPod = _hostDao.searchIncludingRemoved(sc, null, false, false); if (hostsInPod.size() > 0) { if (cluster == null) { cluster = new ClusterVO(zoneId, podId, String.valueOf(podId)); cluster = _clusterDao.persist(cluster); } for (HostVO host : hostsInPod) { host.setClusterId(cluster.getId()); _hostDao.update(host.getId(), host); System.out.println("Join host " + host.getName() + " to auto-formed cluster"); } } SearchBuilder<StoragePoolVO> sbPool = _spDao.createSearchBuilder(); sbPool.and("dc", sbPool.entity().getDataCenterId(), Op.EQ); sbPool.and("pod", sbPool.entity().getPodId(), Op.EQ); sbPool.and("poolType", sbPool.entity().getPoolType(), Op.IN); sbPool.done(); SearchCriteria<StoragePoolVO> scPool = sbPool.create(); scPool.setParameters("dc", zoneId); scPool.setParameters("pod", podId); scPool.setParameters("poolType", StoragePoolType.NetworkFilesystem.toString(), StoragePoolType.IscsiLUN.toString()); List<StoragePoolVO> sPoolsInPod = _spDao.searchIncludingRemoved(scPool, null, false, false); if (sPoolsInPod.size() > 0) { if (cluster == null) { cluster = new ClusterVO(zoneId, podId, String.valueOf(podId)); cluster = _clusterDao.persist(cluster); } for (StoragePoolVO spool : sPoolsInPod) { spool.setClusterId(cluster.getId()); _spDao.update(spool.getId(), spool); System.out.println("Join host " + spool.getName() + " to auto-formed cluster"); } } } private void composeDomainPath(DomainVO domain, StringBuilder sb) { if (domain.getParent() == null) { sb.append("/"); } else { DomainVO parent = _domainDao.findById(domain.getParent()); composeDomainPath(parent, sb); if (domain.getName().contains("/")) { System.out.println( "Domain " + domain.getName() + " contains invalid domain character, replace it with -"); sb.append(domain.getName().replace('/', '-')); } else { sb.append(domain.getName()); } sb.append("/"); } } private void migrateDomains() { System.out.println("Migrating domains..."); // we shouldn't have too many domains in the system, use a very dumb way to setup domain path List<DomainVO> domains = _domainDao.listAllIncludingRemoved(); for (DomainVO domain : domains) { StringBuilder path = new StringBuilder(); composeDomainPath(domain, path); System.out.println("Convert domain path, domin: " + domain.getId() + ", path:" + path.toString()); domain.setPath(path.toString()); _domainDao.update(domain.getId(), domain); } System.out.println("All domains have been migrated to 2.1 format"); } private void migrateServiceOfferings() { System.out.println("Migrating service offering..."); long seq = getServiceOfferingStartSequence(); List<ServiceOffering20VO> oldServiceOfferings = _serviceOffering20Dao.listAllIncludingRemoved(); for (ServiceOffering20VO so20 : oldServiceOfferings) { ServiceOffering21VO so21 = new ServiceOffering21VO(so20.getName(), so20.getCpu(), so20.getRamSize(), so20.getSpeed(), so20.getRateMbps(), so20.getMulticastRateMbps(), so20.getOfferHA(), so20.getDisplayText(), so20.getUseLocalStorage(), false, null); so21.setId(seq++); so21.setDiskSize(0); so21 = _serviceOffering21Dao.persist(so21); if (so20.getId().longValue() != so21.getId()) { // Update all foreign reference from old value to new value, need to be careful with foreign key constraints updateServiceOfferingReferences(so20.getId().longValue(), so21.getId()); } } boolean useLocalStorage = Boolean.parseBoolean(_configDao.getValue(Config.SystemVMUseLocalStorage.key())); // create service offering for system VMs and update references int proxyRamSize = NumbersUtil.parseInt(_configDao.getValue(Config.ConsoleProxyRamSize.key()), ConsoleProxyManager.DEFAULT_PROXY_VM_RAMSIZE); ServiceOffering21VO soConsoleProxy = new ServiceOffering21VO("Fake Offering For DomP", 1, proxyRamSize, 0, 0, 0, false, null, useLocalStorage, true, null); soConsoleProxy.setId(seq++); soConsoleProxy.setUniqueName("Cloud.com-ConsoleProxy"); soConsoleProxy = _serviceOffering21Dao.persist(soConsoleProxy); _consoleProxyServiceOfferingId = soConsoleProxy.getId(); int secStorageVmRamSize = NumbersUtil.parseInt(_configDao.getValue(Config.SecStorageVmRamSize.key()), SecondaryStorageVmManager.DEFAULT_SS_VM_RAMSIZE); ServiceOffering21VO soSecondaryVm = new ServiceOffering21VO("Fake Offering For Secondary Storage VM", 1, secStorageVmRamSize, 0, 0, 0, false, null, useLocalStorage, true, null); soSecondaryVm.setId(seq++); soSecondaryVm.setUniqueName("Cloud.com-SecondaryStorage"); soSecondaryVm = _serviceOffering21Dao.persist(soSecondaryVm); _secStorageServiceOfferingId = soSecondaryVm.getId(); int routerRamSize = NumbersUtil.parseInt(_configDao.getValue("router.ram.size"), 128); ServiceOffering21VO soDomainRouter = new ServiceOffering21VO("Fake Offering For DomR", 1, routerRamSize, 0, 0, 0, false, null, useLocalStorage, true, null); soDomainRouter.setId(seq++); soDomainRouter.setUniqueName("Cloud.Com-SoftwareRouter"); soDomainRouter = _serviceOffering21Dao.persist(soDomainRouter); _domRServiceOfferingId = soDomainRouter.getId(); System.out.println("Service offering has been migrated to 2.1 format"); } private long getServiceOfferingStartSequence() { Transaction txn = Transaction.open(Transaction.CLOUD_DB); long seq = 0; try { PreparedStatement pstmt = null; pstmt = txn.prepareAutoCloseStatement("SELECT max(id) FROM service_offering"); ResultSet rs = pstmt.executeQuery(); rs.next(); seq = rs.getLong(1); pstmt.close(); pstmt = txn.prepareAutoCloseStatement("SELECT max(id) FROM disk_offering"); rs = pstmt.executeQuery(); rs.next(); seq += rs.getLong(1); pstmt.close(); seq += 100; // add a gap return seq; } catch (SQLException e) { s_logger.error("Unhandled exception: ", e); } finally { txn.close(); } return 10000; } private void updateConsoleProxyServiceOfferingReferences(long serviceOfferingId) { Transaction txn = Transaction.open(Transaction.CLOUD_DB); try { PreparedStatement pstmt = null; pstmt = txn.prepareAutoCloseStatement( "UPDATE volumes SET disk_offering_id=? WHERE instance_id IN (SELECT id FROM vm_instance WHERE type='ConsoleProxy')"); pstmt.setLong(1, serviceOfferingId); int rows = pstmt.executeUpdate(); s_logger.info("Update volumes for console proxy service offering change, affected rows: " + rows); } catch (SQLException e) { s_logger.error("Unhandled exception: ", e); } finally { txn.close(); } } private void updateSecondaryStorageServiceOfferingReferences(long serviceOfferingId) { Transaction txn = Transaction.open(Transaction.CLOUD_DB); try { PreparedStatement pstmt = null; pstmt = txn.prepareAutoCloseStatement( "UPDATE volumes SET disk_offering_id=? WHERE instance_id IN (SELECT id FROM vm_instance WHERE type='SecondaryStorageVm')"); pstmt.setLong(1, serviceOfferingId); int rows = pstmt.executeUpdate(); s_logger.info("Update volumes for secondary storage service offering change, affected rows: " + rows); } catch (SQLException e) { s_logger.error("Unhandled exception: ", e); } finally { txn.close(); } } private void updateDomainRouterServiceOfferingReferences(long serviceOfferingId) { Transaction txn = Transaction.open(Transaction.CLOUD_DB); try { PreparedStatement pstmt = null; pstmt = txn.prepareAutoCloseStatement( "UPDATE volumes SET disk_offering_id=? WHERE instance_id IN (SELECT id FROM vm_instance WHERE type='DomainRouter')"); pstmt.setLong(1, serviceOfferingId); int rows = pstmt.executeUpdate(); s_logger.info("Update volumes for secondary storage service offering change, affected rows: " + rows); } catch (SQLException e) { s_logger.error("Unhandled exception: ", e); } finally { txn.close(); } } private void updateServiceOfferingReferences(long oldServiceOfferingId, long newServiceOfferingId) { Transaction txn = Transaction.open(Transaction.CLOUD_DB); try { PreparedStatement pstmt = null; pstmt = txn.prepareAutoCloseStatement( "UPDATE user_vm SET service_offering_id=? WHERE service_offering_id=?"); pstmt.setLong(1, newServiceOfferingId); pstmt.setLong(2, oldServiceOfferingId); int rows = pstmt.executeUpdate(); s_logger.info("Update user_vm for service offering change (" + oldServiceOfferingId + "->" + newServiceOfferingId + "), affected rows: " + rows); } catch (SQLException e) { s_logger.error("Unhandled exception: ", e); } finally { txn.close(); } } private void migrateDiskOfferings() { System.out.println("Migrating disk offering..."); List<DiskOffering20VO> oldDiskOfferings = _diskOffering20Dao.listAllIncludingRemoved(); long maxDiskOfferingId = _domRServiceOfferingId; maxDiskOfferingId += 100; for (DiskOffering20VO do20 : oldDiskOfferings) { DiskOffering21VO do21 = new DiskOffering21VO(do20.getDomainId(), do20.getName(), do20.getDisplayText(), do20.getDiskSize(), do20.getMirrored(), null); do21.setType(Type.Disk); do21.setId(maxDiskOfferingId++); do21 = _diskOffering21Dao.persist(do21); if (do20.getId().longValue() != do21.getId()) { updateDiskOfferingReferences(do20.getId().longValue(), do21.getId()); } } FixupNullDiskOfferingInVolumes(); System.out.println("Disk offering has been migrated to 2.1 format"); } private void FixupNullDiskOfferingInVolumes() { System.out.println("Fixup NULL disk_offering_id references in volumes table ..."); SearchCriteria<DiskOffering21VO> scDiskOffering = _diskOffering21Dao.createSearchCriteria(); List<DiskOffering21VO> offeringList = _diskOffering21Dao.searchIncludingRemoved(scDiskOffering, new Filter(DiskOffering21VO.class, "diskSize", true, null, null), false, false); for (DiskOffering21VO offering : offeringList) { s_logger.info( "Disk offering name: " + offering.getName() + ", disk size: " + offering.getDiskSizeInBytes()); } SearchBuilder<VolumeVO> sb = _volumeDao.createSearchBuilder(); sb.and("diskOfferingId", sb.entity().getDiskOfferingId(), Op.NULL); sb.done(); SearchCriteria<VolumeVO> sc = sb.create(); List<VolumeVO> volumes = _volumeDao.searchIncludingRemoved(sc, null, false, false); if (volumes.size() > 0) { for (VolumeVO vol : volumes) { if (vol.getInstanceId() != null) { VMInstanceVO vmInstance = _vmInstanceDao.findById(vol.getInstanceId()); if (vmInstance.getType() == VirtualMachine.Type.User) { // if the volume is for user VM, we can retrieve the information from service_offering_id UserVmVO userVm = _userVmDao.findById(vol.getInstanceId()); if (userVm != null) { // following operation requires that all service offerings should have been fixed up already vol.setDiskOfferingId(userVm.getServiceOfferingId()); } else { System.out.println("Data integrity could not be fixed up for volume: " + vol.getId() + " because its owner user vm no longer exists"); } } else if (vmInstance.getType() == VirtualMachine.Type.ConsoleProxy) { vol.setDiskOfferingId(this._consoleProxyServiceOfferingId); } else if (vmInstance.getType() == VirtualMachine.Type.SecondaryStorageVm) { vol.setDiskOfferingId(this._secStorageServiceOfferingId); } else if (vmInstance.getType() == VirtualMachine.Type.DomainRouter) { vol.setDiskOfferingId(this._domRServiceOfferingId); } } else { System.out.println("volume: " + vol.getId() + " is standalone, fix disck_offering_id based on volume size"); // try to guess based on volume size and fill it in boolean found = false; for (DiskOffering21VO do21 : offeringList) { if (do21.getType() == Type.Disk && vol.getSize() > do21.getDiskSizeInBytes()) { found = true; System.out.println( "volume: " + vol.getId() + " disck_offering_id is fixed to " + do21.getId()); vol.setDiskOfferingId(do21.getId()); break; } } if (!found) { System.out.println("volume: " + vol.getId() + " disck_offering_id is fixed to " + offeringList.get(offeringList.size() - 1).getId()); vol.setDiskOfferingId(offeringList.get(offeringList.size() - 1).getId()); } } _volumeDao.update(vol.getId(), vol); } } System.out.println("Disk offering fixup is done"); } private void updateDiskOfferingReferences(long oldDiskOfferingId, long newDiskOfferingId) { Transaction txn = Transaction.open(Transaction.CLOUD_DB); try { PreparedStatement pstmt = null; pstmt = txn.prepareAutoCloseStatement("UPDATE vm_disk SET disk_offering_id=? WHERE disk_offering_id=?"); pstmt.setLong(1, newDiskOfferingId); pstmt.setLong(2, oldDiskOfferingId); int rows = pstmt.executeUpdate(); pstmt.close(); s_logger.info("Update vm_disk for disk offering change (" + oldDiskOfferingId + "->" + newDiskOfferingId + "), affected rows: " + rows); pstmt = txn.prepareAutoCloseStatement("UPDATE volumes SET disk_offering_id=? WHERE disk_offering_id=?"); pstmt.setLong(1, newDiskOfferingId); pstmt.setLong(2, oldDiskOfferingId); rows = pstmt.executeUpdate(); pstmt.close(); s_logger.info("Update volumes for disk offering change (" + oldDiskOfferingId + "->" + newDiskOfferingId + "), affected rows: " + rows); } catch (SQLException e) { s_logger.error("Unhandled exception: ", e); } finally { txn.close(); } } private void migrateSystemVmGuestMacAndState(long zoneId) { // for console proxy VMs SearchBuilder<ConsoleProxyVO> sb = _consoleProxyDao.createSearchBuilder(); sb.and("zoneId", sb.entity().getDataCenterIdToDeployIn(), Op.EQ); sb.done(); SearchCriteria<ConsoleProxyVO> sc = sb.create(); sc.setParameters("zoneId", zoneId); List<ConsoleProxyVO> proxies = _consoleProxyDao.searchIncludingRemoved(sc, null, false, false); for (ConsoleProxyVO proxy : proxies) { String[] macAddresses = _dcDao.getNextAvailableMacAddressPair(zoneId, (1L << 31)); String guestMacAddress = macAddresses[0]; if (proxy.getState() == State.Running || proxy.getState() == State.Starting) { System.out.println("System VM " + proxy.getHostName() + " is in active state, mark it to Stopping state for migration"); proxy.setState(State.Stopping); } String guestIpAddress = _dcDao.allocateLinkLocalIpAddress(proxy.getDataCenterIdToDeployIn(), proxy.getPodIdToDeployIn(), proxy.getId(), null); System.out.println("Assign link loal address to proxy " + proxy.getHostName() + ", link local address: " + guestIpAddress); _consoleProxyDao.update(proxy.getId(), proxy); } // for secondary storage VMs SearchBuilder<SecondaryStorageVmVO> sb2 = _secStorageVmDao.createSearchBuilder(); sb2.and("zoneId", sb2.entity().getDataCenterIdToDeployIn(), Op.EQ); sb2.done(); SearchCriteria<SecondaryStorageVmVO> sc2 = sb2.create(); sc2.setParameters("zoneId", zoneId); List<SecondaryStorageVmVO> secStorageVms = _secStorageVmDao.searchIncludingRemoved(sc2, null, false, false); for (SecondaryStorageVmVO secStorageVm : secStorageVms) { String[] macAddresses = _dcDao.getNextAvailableMacAddressPair(zoneId, (1L << 31)); String guestMacAddress = macAddresses[0]; if (secStorageVm.getState() == State.Running || secStorageVm.getState() == State.Starting) { System.out.println("System VM " + secStorageVm.getHostName() + " is in active state, mark it to Stopping state for migration"); secStorageVm.setState(State.Stopping); } String guestIpAddress = _dcDao.allocateLinkLocalIpAddress(secStorageVm.getDataCenterIdToDeployIn(), secStorageVm.getPodIdToDeployIn(), secStorageVm.getId(), null); System.out.println("Assign link loal address to secondary storage VM " + secStorageVm.getHostName() + ", link local address: " + guestIpAddress); _secStorageVmDao.update(secStorageVm.getId(), secStorageVm); } // for Domain Router VMs // Although we can list those we are interested, but just too lazy, list all of them and check their states. SearchBuilder<DomainRouterVO> sb3 = _routerDao.createSearchBuilder(); sb3.and("zoneId", sb3.entity().getDataCenterIdToDeployIn(), Op.EQ); sb3.done(); SearchCriteria<DomainRouterVO> sc3 = sb3.create(); sc3.setParameters("zoneId", zoneId); List<DomainRouterVO> domRs = _routerDao.searchIncludingRemoved(sc3, null, false, false); for (DomainRouterVO router : domRs) { if (router.getState() == State.Running || router.getState() == State.Starting) { router.setState(State.Stopping); System.out.println("System VM " + router.getHostName() + " is in active state, mark it to Stopping state for migration"); _routerDao.update(router.getId(), router); } } } private void migrateVmInstanceLastHostId(long zoneId, long podId) { SearchBuilder<VMInstanceVO> sb = _vmInstanceDao.createSearchBuilder(); sb.and("zoneId", sb.entity().getDataCenterIdToDeployIn(), Op.EQ); sb.and("podId", sb.entity().getPodIdToDeployIn(), Op.EQ); sb.done(); Random rand = new Random(); SearchCriteria<VMInstanceVO> sc = sb.create(); sc.setParameters("zoneId", zoneId); sc.setParameters("podId", podId); List<VMInstanceVO> vmInstances = _vmInstanceDao.searchIncludingRemoved(sc, null, false, false); List<HostVO> podHosts = getHostsInPod(zoneId, podId); for (VMInstanceVO vm : vmInstances) { if (vm.getHostId() != null) { vm.setLastHostId(vm.getHostId()); } else { if (podHosts.size() > 0) { int next = rand.nextInt(podHosts.size()); vm.setLastHostId(podHosts.get(next).getId()); } } _vmInstanceDao.update(vm.getId(), vm); } } private List<HostVO> getHostsInPod(long zoneId, long podId) { SearchBuilder<HostVO> sb = _hostDao.createSearchBuilder(); sb.and("zoneId", sb.entity().getDataCenterId(), Op.EQ); sb.and("podId", sb.entity().getPodId(), Op.EQ); sb.and("type", sb.entity().getType(), Op.EQ); sb.done(); SearchCriteria<HostVO> sc = sb.create(); sc.setParameters("zoneId", zoneId); sc.setParameters("podId", podId); sc.setParameters("type", Host.Type.Routing.toString()); return _hostDao.searchIncludingRemoved(sc, null, false, false); } private void migrateVolumDeviceIds() { System.out.println("Migrating device_id for volumes, this may take a while, please wait..."); SearchCriteria<VMInstanceVO> sc = _vmInstanceDao.createSearchCriteria(); List<VMInstanceVO> vmInstances = _vmInstanceDao.searchIncludingRemoved(sc, null, false, false); long deviceId = 1; for (VMInstanceVO vm : vmInstances) { SearchBuilder<VolumeVO> sb = _volumeDao.createSearchBuilder(); sb.and("instanceId", sb.entity().getInstanceId(), Op.EQ); sb.done(); SearchCriteria<VolumeVO> sc2 = sb.create(); sc2.setParameters("instanceId", vm.getId()); List<VolumeVO> volumes = _volumeDao.searchIncludingRemoved(sc2, null, false, false); deviceId = 1; // reset for each VM iteration for (VolumeVO vol : volumes) { if (vol.getVolumeType() == Volume.Type.ROOT) { System.out.println("Setting root volume device id to zero, vol: " + vol.getName() + ", instance: " + vm.getHostName()); vol.setDeviceId(0L); } else if (vol.getVolumeType() == Volume.Type.DATADISK) { System.out.println("Setting data volume device id, vol: " + vol.getName() + ", instance: " + vm.getHostName() + ", device id: " + deviceId); vol.setDeviceId(deviceId); // don't use device ID 3 if (++deviceId == 3) { deviceId++; } } else { System.out.println("Unsupported volume type found for volume: " + vol.getName()); } _volumeDao.update(vol.getId(), vol); } } System.out.println("Migrating device_id for volumes done"); } private void migrateVolumePoolType() { System.out.println("Migrating pool type for volumes..."); SearchCriteria<VolumeVO> sc = _volumeDao.createSearchCriteria(); List<VolumeVO> volumes = _volumeDao.searchIncludingRemoved(sc, null, false, false); for (VolumeVO vol : volumes) { if (vol.getPoolId() != null) { StoragePoolVO pool = _poolDao.findById(vol.getPoolId()); if (pool != null) { vol.setPoolType(pool.getPoolType()); _volumeDao.update(vol.getId(), vol); } else { System.out.println("Unable to determine pool type for volume: " + vol.getName()); } } } System.out.println("Migrating pool type for volumes done"); } private void migrateConfiguration() { System.out.println("Migrating 2.1 configuration variables..."); System.out.print("Are you migrating from 2.0 Premium Edition? (yes/no): "); String answer = readInput(); if (answer != null && answer.equalsIgnoreCase("yes")) { _isPremium = true; } // Save default Configuration Table values List<String> categories = Config.getCategories(); for (String category : categories) { // If this is not a premium environment, don't insert premium configuration values if (!_isPremium && category.equals("Premium")) { continue; } List<Config> configs = Config.getConfigs(category); for (Config c : configs) { String name = c.key(); // If the value is already in the table, don't reinsert it if (_configDao.getValue(name) != null) { continue; } String instance = "DEFAULT"; String component = c.getComponent(); String value = c.getDefaultValue(); String description = c.getDescription(); ConfigurationVO configVO = new ConfigurationVO(category, instance, component, name, value, description); _configDao.persist(configVO); } // If this is a premium environment, set the network type to be "vlan" if (_isPremium) { _configDao.update("network.type", "vlan"); _configDao.update("hypervisor.type", "xenserver"); _configDao.update("secondary.storage.vm", "true"); _configDao.update("secstorage.encrypt.copy", "true"); _configDao.update("secstorage.secure.copy.cert", "realhostip"); } boolean externalIpAlloator = Boolean .parseBoolean(_configDao.getValue("direct.attach.network.externalIpAllocator.enabled")); String hyperVisor = _configDao.getValue("hypervisor.type"); if (hyperVisor.equalsIgnoreCase("KVM") && !externalIpAlloator) { /*For KVM, it's enabled by default*/ _configDao.update("direct.attach.network.externalIpAllocator.enabled", "true"); } // Save the mount parent to the configuration table String mountParent = getMountParent(); if (mountParent != null) { _configDao.update("mount.parent", mountParent); } if (_configDao.getValue("host") == null) { String hostIpAdr = getHost(); if (hostIpAdr != null) { _configDao.update("host", hostIpAdr); } } // generate a single sign-on key updateSSOKey(); } System.out.println("Migrating 2.1 configuration done"); } private String getEthDevice() { String defaultRoute = Script.runSimpleBashScript("/sbin/route | grep default"); if (defaultRoute == null) { return null; } String[] defaultRouteList = defaultRoute.split("\\s+"); if (defaultRouteList.length != 8) { return null; } return defaultRouteList[7]; } protected String getHost() { NetworkInterface nic = null; String pubNic = getEthDevice(); if (pubNic == null) { return null; } try { nic = NetworkInterface.getByName(pubNic); } catch (final SocketException e) { return null; } String[] info = NetUtils.getNetworkParams(nic); return info[0]; } private String getMountParent() { return getEnvironmentProperty("mount.parent"); } private String getEnvironmentProperty(String name) { try { final File propsFile = PropertiesUtil.findConfigFile("environment.properties"); if (propsFile == null) { return null; } else { final FileInputStream finputstream = new FileInputStream(propsFile); final Properties props = new Properties(); props.load(finputstream); finputstream.close(); return props.getProperty("mount.parent"); } } catch (IOException e) { return null; } } private void updateSSOKey() { try { String encodedKey = null; // Algorithm for SSO Keys is SHA1, should this be configuable? KeyGenerator generator = KeyGenerator.getInstance("HmacSHA1"); SecretKey key = generator.generateKey(); encodedKey = Base64.encodeBase64URLSafeString(key.getEncoded()); _configDao.update("security.singlesignon.key", encodedKey); } catch (NoSuchAlgorithmException ex) { s_logger.error("error generating sso key", ex); } } private void doMigration() { setupComponents(); migrateZones(); migrateDomains(); migrateServiceOfferings(); migrateDiskOfferings(); migrateVolumDeviceIds(); migrateVolumePoolType(); migrateConfiguration(); // update disk_offering_id for system VMs. As of the id-space collision for servercie_offering_ids // before and after migration, this should be done in the last step updateConsoleProxyServiceOfferingReferences(_consoleProxyServiceOfferingId); updateSecondaryStorageServiceOfferingReferences(_secStorageServiceOfferingId); updateDomainRouterServiceOfferingReferences(_domRServiceOfferingId); System.out.println("Migration done"); } private String readInput() { try { Scanner in = new Scanner(System.in); String input = in.nextLine(); return input; } catch (NoSuchElementException e) { return ""; } } private void setupComponents() { ComponentLocator.getLocator("migration", "migration-components.xml", "log4j-cloud.xml"); ComponentLocator locator = ComponentLocator.getCurrentLocator(); _configDao = locator.getDao(ConfigurationDao.class); _podDao = locator.getDao(HostPodDao.class); _dcDao = locator.getDao(DataCenterDao.class); _clusterDao = locator.getDao(ClusterDao.class); _hostDao = locator.getDao(HostDao.class); _spDao = locator.getDao(StoragePoolDao.class); _domainDao = locator.getDao(DomainDao.class); _serviceOffering20Dao = locator.getDao(ServiceOffering20Dao.class); _diskOffering20Dao = locator.getDao(DiskOffering20Dao.class); _serviceOffering21Dao = locator.getDao(ServiceOffering21Dao.class); _diskOffering21Dao = locator.getDao(DiskOffering21Dao.class); _consoleProxyDao = locator.getDao(ConsoleProxyDao.class); _secStorageVmDao = locator.getDao(SecondaryStorageVmDao.class); _vmInstanceDao = locator.getDao(VMInstanceDao.class); _volumeDao = locator.getDao(VolumeDao.class); _userVmDao = locator.getDao(UserVmDao.class); _routerDao = locator.getDao(DomainRouterDao.class); _poolDao = locator.getDao(StoragePoolDao.class); } public static void main(String[] args) { File file = PropertiesUtil.findConfigFile("log4j-cloud.xml"); if (file != null) { System.out.println("Log4j configuration from : " + file.getAbsolutePath()); DOMConfigurator.configureAndWatch(file.getAbsolutePath(), 10000); } else { System.out.println("Configure log4j with default properties"); } new Db20to21MigrationUtil().doMigration(); System.exit(0); } }