// 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.IOException;
import java.io.StringReader;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.TimeZone;
import java.util.UUID;

import org.apache.log4j.Logger;

import com.cloud.configuration.Resource.ResourceType;
import com.cloud.event.EventTypes;
import com.cloud.event.EventVO;
import com.cloud.event.UsageEventVO;
import com.cloud.utils.DateUtil;
import com.cloud.utils.NumbersUtil;
import com.cloud.utils.exception.CloudRuntimeException;
import com.cloud.utils.net.NetUtils;
import com.cloud.utils.script.Script;

public class Upgrade218to22 implements DbUpgrade {
    final static Logger s_logger = Logger.getLogger(Upgrade218to22.class);
    boolean _basicZone;

    @Override
    public File[] getPrepareScripts() {
        String file = Script.findScript("", "db/schema-21to22.sql");
        if (file == null) {
            throw new CloudRuntimeException("Unable to find the upgrade script, schema-21to22.sql");
        }

        return new File[] {new File(file)};
    }

    protected void upgradeStoragePools(Connection conn) {
        PreparedStatement pstmt;
        try {
            pstmt = conn.prepareStatement("UPDATE storage_pool SET status='Up'");
            pstmt.executeUpdate();
            pstmt.close();
        } catch (SQLException e) {
            throw new CloudRuntimeException("Can't upgrade storage pool ", e);
        }
    }

    protected long insertNetworkOffering(Connection conn, String name, String displayText, String trafficType, boolean systemOnly, boolean defaultNetworkOffering,
        String availability, boolean dnsService, boolean gatewayService, boolean firewallService, boolean lbService, boolean userdataService, boolean vpnService,
        boolean dhcpService) {
        String insertSql =
            "INSERT INTO network_offerings (name, display_text, nw_rate, mc_rate, concurrent_connections, traffic_type, tags, system_only, specify_vlan, service_offering_id, created, removed, `default`, availability, dnsService, gatewayService, firewallService, lbService, userdataService, vpnService, dhcpService) "
                + "VALUES (?,    ?,            NULL,    NULL,    NULL,                   ?,            NULL, ?,           0,            NULL,                now(),   NULL,    ?,       ?,            ?,           ?,               ?,                ?,          ?,                ?,           ?)";
        try {
            PreparedStatement pstmt = conn.prepareStatement(insertSql, Statement.RETURN_GENERATED_KEYS);
            int i = 1;
            pstmt.setString(i++, name);
            pstmt.setString(i++, displayText);
            pstmt.setString(i++, trafficType);
            pstmt.setBoolean(i++, systemOnly);
            pstmt.setBoolean(i++, defaultNetworkOffering);
            pstmt.setString(i++, availability);
            pstmt.setBoolean(i++, dnsService);
            pstmt.setBoolean(i++, gatewayService);
            pstmt.setBoolean(i++, firewallService);
            pstmt.setBoolean(i++, lbService);
            pstmt.setBoolean(i++, userdataService);
            pstmt.setBoolean(i++, vpnService);
            pstmt.setBoolean(i++, dhcpService);
            pstmt.executeUpdate();
            ResultSet rs = pstmt.getGeneratedKeys();
            rs.next();
            long id = rs.getLong(1);
            rs.close();
            pstmt.close();
            return id;
        } catch (SQLException e) {
            throw new CloudRuntimeException("Unable to insert network offering ", e);
        }
    }

    protected void upgradeInstanceGroups(Connection conn) {
        try {

            // Create instance groups - duplicated names are allowed across accounts
            PreparedStatement pstmt = conn.prepareStatement("SELECT DISTINCT v.group, v.account_id from vm_instance v where v.group is not null");
            ResultSet rs = pstmt.executeQuery();
            ArrayList<Object[]> groups = new ArrayList<Object[]>();
            while (rs.next()) {
                Object[] group = new Object[10];
                group[0] = rs.getString(1); // group name
                group[1] = rs.getLong(2); // accountId
                groups.add(group);
            }
            rs.close();
            pstmt.close();

            for (Object[] group : groups) {
                String groupName = (String)group[0];
                Long accountId = (Long)group[1];
                createInstanceGroups(conn, groupName, accountId);
            }

            // update instance_group_vm_map
            pstmt =
                conn.prepareStatement("SELECT g.id, v.id from vm_instance v, instance_group g where g.name=v.group and g.account_id=v.account_id and v.group is not null");
            rs = pstmt.executeQuery();
            ArrayList<Object[]> groupVmMaps = new ArrayList<Object[]>();
            while (rs.next()) {
                Object[] groupMaps = new Object[10];
                groupMaps[0] = rs.getLong(1); // vmId
                groupMaps[1] = rs.getLong(2); // groupId
                groupVmMaps.add(groupMaps);
            }
            rs.close();
            pstmt.close();

            for (Object[] groupMap : groupVmMaps) {
                Long groupId = (Long)groupMap[0];
                Long instanceId = (Long)groupMap[1];
                createInstanceGroupVmMaps(conn, groupId, instanceId);
            }
        } catch (SQLException e) {
            throw new CloudRuntimeException("Can't update instance groups ", e);
        }

    }

    protected void createInstanceGroups(Connection conn, String groupName, long accountId) throws SQLException {
        PreparedStatement pstmt = conn.prepareStatement("INSERT INTO instance_group (account_id, name, created) values (?, ?, now()) ");
        pstmt.setLong(1, accountId);
        pstmt.setString(2, groupName);
        pstmt.executeUpdate();
        pstmt.close();
    }

    protected void createInstanceGroupVmMaps(Connection conn, long groupId, long instanceId) throws SQLException {
        PreparedStatement pstmt = conn.prepareStatement("INSERT INTO instance_group_vm_map (group_id, instance_id) values (?, ?) ");
        pstmt.setLong(1, groupId);
        pstmt.setLong(2, instanceId);
        pstmt.executeUpdate();
        pstmt.close();
    }

    protected long insertNic(Connection conn, long networkId, long instanceId, boolean running, String macAddress, String ipAddress, String netmask, String strategy,
        String gateway, String vnet, String guru, boolean defNic, int deviceId, String mode, String reservationId) throws SQLException {
        PreparedStatement pstmt =
            conn.prepareStatement(
                "INSERT INTO nics (instance_id, network_id, mac_address, ip4_address, netmask, strategy, ip_type, broadcast_uri, mode, reserver_name, reservation_id, device_id, update_time, isolation_uri, ip6_address, default_nic, created, removed, state, gateway) "
                    + "VALUES (?,           ?,          ?,           ?,           ?,       ?,        'Ip4',   ?,             ?,    ?,             ?,              ?,         now(),       ?,          NULL,         ?,          now(),   NULL,    ?,     ?)",
                Statement.RETURN_GENERATED_KEYS);
        int i = 1;
        String isolationUri = null;

        String broadcast = null;
        if (vnet != null) {
            broadcast = "vlan://" + vnet;
            if (vnet.equalsIgnoreCase("untagged")) {
                isolationUri = "ec2://" + vnet;
            } else {
                isolationUri = broadcast;
            }
        }
        pstmt.setLong(i++, instanceId);
        pstmt.setLong(i++, networkId);
        pstmt.setString(i++, macAddress);
        pstmt.setString(i++, ipAddress);
        pstmt.setString(i++, netmask);
        pstmt.setString(i++, strategy);
        pstmt.setString(i++, broadcast);
        pstmt.setString(i++, mode);
        pstmt.setString(i++, guru);
        pstmt.setString(i++, reservationId);
        pstmt.setInt(i++, deviceId);
        pstmt.setString(i++, isolationUri);
        pstmt.setBoolean(i++, defNic);
        pstmt.setString(i++, running ? "Reserved" : "Allocated");
        pstmt.setString(i++, gateway);
        pstmt.executeUpdate();
        ResultSet rs = pstmt.getGeneratedKeys();
        long nicId = 0;
        if (!rs.next()) {
            throw new CloudRuntimeException("Unable to get id for nic");
        }
        nicId = rs.getLong(1);
        rs.close();
        pstmt.close();
        return nicId;
    }

    protected void upgradeDomR(Connection conn, long dcId, long domrId, Long publicNetworkId, long guestNetworkId, long controlNetworkId, String zoneType, String vnet)
        throws SQLException {
        s_logger.debug("Upgrading domR" + domrId);
        PreparedStatement pstmt =
            conn.prepareStatement("SELECT vm_instance.id, vm_instance.state, vm_instance.private_mac_address, vm_instance.private_ip_address, vm_instance.private_netmask, domain_router.public_mac_address, domain_router.public_ip_address, domain_router.public_netmask, domain_router.guest_mac_address, domain_router.guest_ip_address, domain_router.guest_netmask, domain_router.vnet, domain_router.gateway FROM vm_instance INNER JOIN domain_router ON vm_instance.id=domain_router.id WHERE vm_instance.removed is NULL AND vm_instance.id=?");
        pstmt.setLong(1, domrId);
        ResultSet rs = pstmt.executeQuery();

        if (!rs.next()) {
            throw new CloudRuntimeException("Unable to find router " + domrId);
        }

        // long id = rs.getLong(1);
        String state = rs.getString(2);
        boolean running = state.equals("Running") | state.equals("Starting") | state.equals("Stopping");
        String privateMac = rs.getString(3);
        String privateIp = rs.getString(4);
        String privateNetmask = rs.getString(5);
        String publicMac = rs.getString(6);
        String publicIp = rs.getString(7);
        String publicNetmask = rs.getString(8);
        String guestMac = rs.getString(9);
        String guestIp = rs.getString(10);
        String guestNetmask = rs.getString(11);
        String gateway = rs.getString(13);
        rs.close();
        pstmt.close();

        pstmt = conn.prepareStatement("SELECT v.vlan_id from vlan v, user_ip_address u where v.id=u.vlan_db_id and u.public_ip_address=?");
        pstmt.setString(1, publicIp);
        rs = pstmt.executeQuery();

        String publicVlan = null;
        while (rs.next()) {
            publicVlan = rs.getString(1);
        }

        // Control nic is the same for all types of networks
        long controlNicId =
            insertNic(conn, controlNetworkId, domrId, running, privateMac, privateIp, privateNetmask, "Start", "169.254.0.1", null, "ControlNetworkGuru", false, 1,
                "Static", privateIp != null ? (domrId + privateIp) : null);
        if (privateIp != null) {
            pstmt = conn.prepareStatement("UPDATE op_dc_link_local_ip_address_alloc SET instance_id=? WHERE ip_address=? AND data_center_id=?");
            pstmt.setLong(1, controlNicId);
            pstmt.setString(2, privateIp);
            pstmt.setLong(3, dcId);
            pstmt.executeUpdate();
            pstmt.close();
        }

        if (zoneType.equalsIgnoreCase("Basic")) {
            insertNic(conn, guestNetworkId, domrId, running, guestMac, guestIp, guestNetmask, "Create", gateway, vnet, "DirectPodBasedNetworkGuru", true, 0, "Dhcp", null);
        } else if (publicIp != null) {
            // update virtual domR
            insertNic(conn, publicNetworkId, domrId, running, publicMac, publicIp, publicNetmask, "Create", gateway, publicVlan, "PublicNetworkGuru", true, 2, "Static",
                null);
            insertNic(conn, guestNetworkId, domrId, running, guestMac, guestIp, guestNetmask, "Start", null, vnet, "ExternalGuestNetworkGuru", false, 0, "Dhcp", null);
        } else {
            // update direct domR - dhcp case
            insertNic(conn, guestNetworkId, domrId, running, guestMac, guestIp, guestNetmask, "Create", gateway, vnet, "DirectNetworkGuru", true, 0, "Dhcp", null);
        }

    }

    protected void upgradeSsvm(Connection conn, long dataCenterId, long publicNetworkId, long managementNetworkId, long controlNetworkId, String zoneType)
        throws SQLException {
        s_logger.debug("Upgrading ssvm in " + dataCenterId);
        PreparedStatement pstmt =
            conn.prepareStatement("SELECT vm_instance.id, vm_instance.state, vm_instance.private_mac_address, vm_instance.private_ip_address, vm_instance.private_netmask, secondary_storage_vm.public_mac_address, secondary_storage_vm.public_ip_address, secondary_storage_vm.public_netmask, secondary_storage_vm.guest_mac_address, secondary_storage_vm.guest_ip_address, secondary_storage_vm.guest_netmask, secondary_storage_vm.gateway, vm_instance.type FROM vm_instance INNER JOIN secondary_storage_vm ON vm_instance.id=secondary_storage_vm.id WHERE vm_instance.removed is NULL AND vm_instance.data_center_id=? AND vm_instance.type='SecondaryStorageVm'");
        pstmt.setLong(1, dataCenterId);
        ResultSet rs = pstmt.executeQuery();

        if (!rs.next()) {
            s_logger.debug("Unable to find ssvm in data center " + dataCenterId);
            return;
        }

        long ssvmId = rs.getLong(1);
        String state = rs.getString(2);
        boolean running = state.equals("Running") | state.equals("Starting") | state.equals("Stopping");
        String privateMac = rs.getString(3);
        String privateIp = rs.getString(4);
        String privateNetmask = rs.getString(5);
        String publicMac = rs.getString(6);
        String publicIp = rs.getString(7);
        String publicNetmask = rs.getString(8);
        String guestMac = rs.getString(9);
        String guestIp = rs.getString(10);
        String guestNetmask = rs.getString(11);
        String gateway = rs.getString(12);
        String type = rs.getString(13);
        rs.close();
        pstmt.close();

        pstmt =
            conn.prepareStatement("SELECT host_pod_ref.gateway from host_pod_ref INNER JOIN vm_instance ON vm_instance.pod_id=host_pod_ref.id WHERE vm_instance.removed is NULL AND vm_instance.data_center_id=? AND vm_instance.type='SecondaryStorageVm'");
        pstmt.setLong(1, dataCenterId);
        rs = pstmt.executeQuery();

        if (!rs.next()) {
            s_logger.debug("Unable to find ssvm in data center " + dataCenterId);
            return;
        }

        String podGateway = rs.getString(1);
        rs.close();
        pstmt.close();

        pstmt = conn.prepareStatement("SELECT v.vlan_id from vlan v, user_ip_address u where v.id=u.vlan_db_id and u.public_ip_address=?");
        pstmt.setString(1, publicIp);
        rs = pstmt.executeQuery();

        String publicVlan = null;
        while (rs.next()) {
            publicVlan = rs.getString(1);
        }

        rs.close();
        pstmt.close();

        if (zoneType.equalsIgnoreCase("Basic")) {
            insertNic(conn, publicNetworkId, ssvmId, running, publicMac, publicIp, publicNetmask, "Create", gateway, publicVlan, "DirectPodBasedNetworkGuru", true, 2,
                "Dhcp", null);

        } else {
            insertNic(conn, publicNetworkId, ssvmId, running, publicMac, publicIp, publicNetmask, "Create", gateway, publicVlan, "PublicNetworkGuru", true, 2, "Static",
                null);
        }

        long controlNicId =
            insertNic(conn, controlNetworkId, ssvmId, running, guestMac, guestIp, guestNetmask, "Start", "169.254.0.1", null, "ControlNetworkGuru", false, 0, "Static",
                guestIp != null ? (ssvmId + guestIp) : null);
        if (guestIp != null) {
            pstmt = conn.prepareStatement("UPDATE op_dc_link_local_ip_address_alloc SET instance_id=? WHERE ip_address=? AND data_center_id=?");
            pstmt.setLong(1, controlNicId);
            pstmt.setString(2, guestIp);
            pstmt.setLong(3, dataCenterId);
            pstmt.executeUpdate();
            pstmt.close();
        }

        long mgmtNicId =
            insertNic(conn, managementNetworkId, ssvmId, running, privateMac, privateIp, privateNetmask, "Start", podGateway, null, "PodBasedNetworkGuru", false, 1,
                "Static", null);
        if (privateIp != null) {
            pstmt = conn.prepareStatement("UPDATE op_dc_ip_address_alloc SET instance_id=? WHERE ip_address=? AND data_center_id=?");
            pstmt.setLong(1, mgmtNicId);
            pstmt.setString(2, privateIp);
            pstmt.setLong(3, dataCenterId);
            pstmt.executeUpdate();
            pstmt.close();
        }
    }

    protected void upgradeConsoleProxy(Connection conn, long dcId, long cpId, long publicNetworkId, long managementNetworkId, long controlNetworkId, String zoneType)
        throws SQLException {
        s_logger.debug("Upgrading cp" + cpId);
        PreparedStatement pstmt =
            conn.prepareStatement("SELECT vm_instance.id, vm_instance.state, vm_instance.private_mac_address, vm_instance.private_ip_address, vm_instance.private_netmask, console_proxy.public_mac_address, console_proxy.public_ip_address, console_proxy.public_netmask, console_proxy.guest_mac_address, console_proxy.guest_ip_address, console_proxy.guest_netmask, console_proxy.gateway, vm_instance.type FROM vm_instance INNER JOIN console_proxy ON vm_instance.id=console_proxy.id WHERE vm_instance.removed is NULL AND vm_instance.id=?");
        pstmt.setLong(1, cpId);
        ResultSet rs = pstmt.executeQuery();

        if (!rs.next()) {
            throw new CloudRuntimeException("Unable to find cp " + cpId);
        }

        long id = rs.getLong(1);
        String state = rs.getString(2);
        boolean running = state.equals("Running") | state.equals("Starting") | state.equals("Stopping");
        String privateMac = rs.getString(3);
        String privateIp = rs.getString(4);
        String privateNetmask = rs.getString(5);
        String publicMac = rs.getString(6);
        String publicIp = rs.getString(7);
        String publicNetmask = rs.getString(8);
        String guestMac = rs.getString(9);
        String guestIp = rs.getString(10);
        String guestNetmask = rs.getString(11);
        String gateway = rs.getString(12);
        String type = rs.getString(13);
        rs.close();
        pstmt.close();

        pstmt =
            conn.prepareStatement("SELECT host_pod_ref.gateway from host_pod_ref INNER JOIN vm_instance ON vm_instance.pod_id=host_pod_ref.id WHERE vm_instance.id=?");
        pstmt.setLong(1, cpId);
        rs = pstmt.executeQuery();

        if (!rs.next()) {
            throw new CloudRuntimeException("Unable to find cp " + cpId);
        }

        String podGateway = rs.getString(1);
        rs.close();
        pstmt.close();

        pstmt = conn.prepareStatement("SELECT v.vlan_id from vlan v, user_ip_address u where v.id=u.vlan_db_id and u.public_ip_address=?");
        pstmt.setString(1, publicIp);
        rs = pstmt.executeQuery();

        String publicVlan = null;
        while (rs.next()) {
            publicVlan = rs.getString(1);
        }

        rs.close();
        pstmt.close();

        if (zoneType.equalsIgnoreCase("Basic")) {
            insertNic(conn, publicNetworkId, cpId, running, publicMac, publicIp, publicNetmask, "Create", gateway, publicVlan, "DirectPodBasedNetworkGuru", true, 2,
                "Dhcp", null);
        } else {
            insertNic(conn, publicNetworkId, cpId, running, publicMac, publicIp, publicNetmask, "Create", gateway, publicVlan, "PublicNetworkGuru", true, 2, "Static",
                null);
        }

        long controlNicId =
            insertNic(conn, controlNetworkId, cpId, running, guestMac, guestIp, guestNetmask, "Start", "169.254.0.1", null, "ControlNetworkGuru", false, 0, "Static",
                guestIp != null ? (cpId + guestIp) : null);
        if (guestIp != null) {
            pstmt = conn.prepareStatement("UPDATE op_dc_link_local_ip_address_alloc SET instance_id=? WHERE ip_address=? AND data_center_id=?");
            pstmt.setLong(1, controlNicId);
            pstmt.setString(2, guestIp);
            pstmt.setLong(3, dcId);
            pstmt.executeUpdate();
            pstmt.close();
        }
        long mgmtNicId =
            insertNic(conn, managementNetworkId, cpId, running, privateMac, privateIp, privateNetmask, "Start", podGateway, null, "PodBasedNetworkGuru", false, 1,
                "Static", privateIp != null ? (cpId + privateIp) : null);
        if (privateIp != null) {
            pstmt = conn.prepareStatement("UPDATE op_dc_ip_address_alloc SET instance_id=? WHERE ip_address=? AND data_center_id=?");
            pstmt.setLong(1, mgmtNicId);
            pstmt.setString(2, privateIp);
            pstmt.setLong(3, dcId);
            pstmt.executeUpdate();
            pstmt.close();
        }
    }

    protected void upgradeUserVms(Connection conn, long domainRouterId, long networkId, String gateway, String vnet, String guruName, String strategy)
        throws SQLException {
        PreparedStatement pstmt =
            conn.prepareStatement("SELECT vm_instance.id, vm_instance.private_mac_address, vm_instance.private_ip_address, vm_instance.private_netmask, vm_instance.state, vm_instance.type FROM vm_instance INNER JOIN user_vm ON vm_instance.id=user_vm.id WHERE user_vm.domain_router_id=? and vm_instance.removed IS NULL");
        pstmt.setLong(1, domainRouterId);
        ResultSet rs = pstmt.executeQuery();
        List<Object[]> vms = new ArrayList<Object[]>();
        while (rs.next()) {
            Object[] vm = new Object[10];
            vm[0] = rs.getLong(1); // vm id
            vm[1] = rs.getString(2); // mac address
            vm[2] = rs.getString(3); // ip address
            vm[3] = rs.getString(4); // netmask
            vm[4] = rs.getString(5); // vm state
            vms.add(vm);
        }
        rs.close();
        pstmt.close();

        s_logger.debug("Upgrading " + vms.size() + " vms for router " + domainRouterId);

        int count = 0;
        for (Object[] vm : vms) {
            String state = (String)vm[4];

            boolean running = false;
            if (state.equals("Running") || state.equals("Starting") || state.equals("Stopping")) {
                running = true;
                count++;
            }

            insertNic(conn, networkId, (Long)vm[0], running, (String)vm[1], (String)vm[2], (String)vm[3], strategy, gateway, vnet, guruName, true, 0, "Dhcp", null);
        }

        pstmt = conn.prepareStatement("SELECT state FROM vm_instance WHERE id=?");
        pstmt.setLong(1, domainRouterId);
        rs = pstmt.executeQuery();
        rs.next();
        String state = rs.getString(1);
        if (state.equals("Running") || state.equals("Starting") || state.equals("Stopping")) {
            count++;
        }
        rs.close();
        pstmt.close();

        Long originalNicsCount = 0L;
        pstmt = conn.prepareStatement("SELECT nics_count from op_networks where id=?");
        pstmt.setLong(1, networkId);
        ResultSet originalCountRs = pstmt.executeQuery();

        if (originalCountRs.next()) {
            originalNicsCount = originalCountRs.getLong(1);
        }

        Long resultCount = originalNicsCount + count;
        originalCountRs.close();
        pstmt.close();

        pstmt = conn.prepareStatement("UPDATE op_networks SET nics_count=?, check_for_gc=? WHERE id=?");
        pstmt.setLong(1, resultCount);
        if (count == 0) {
            pstmt.setBoolean(2, false);
        } else {
            pstmt.setBoolean(2, true);
        }
        pstmt.setLong(3, networkId);
        pstmt.executeUpdate();
        pstmt.close();
    }

    protected long insertNetwork(Connection conn, String name, String displayText, String trafficType, String broadcastDomainType, String broadcastUri, String gateway,
        String cidr, String mode, long networkOfferingId, long dataCenterId, String guruName, String state, long domainId, long accountId, String dns1, String dns2,
        String guestType, boolean shared, String networkDomain, boolean isDefault, String reservationId) {
        String getNextNetworkSequenceSql = "SELECT value from sequence where name='networks_seq'";
        String advanceNetworkSequenceSql = "UPDATE sequence set value=value+1 where name='networks_seq'";
        String insertNetworkSql =
            "INSERT INTO networks(id, name, display_text, traffic_type, broadcast_domain_type, gateway, cidr, mode, network_offering_id, data_center_id, guru_name, state, domain_id, account_id, dns1, dns2, guest_type, shared, is_default, created, network_domain, related, reservation_id, broadcast_uri) "
                + "VALUES(?,  ?,    ?,            ?,            ?,                     ?,       ?,    ?,    ?,                   ?,              ?,         ?,     ?,         ?,          ?,    ?,    ?,          ?,      ?,          now(),   ?,              ?,       ?,              ?)";
        try {
            PreparedStatement pstmt = conn.prepareStatement(getNextNetworkSequenceSql);
            ResultSet rs = pstmt.executeQuery();
            rs.next();
            long seq = rs.getLong(1);
            rs.close();
            pstmt.close();

            pstmt = conn.prepareStatement(advanceNetworkSequenceSql);
            pstmt.executeUpdate();
            pstmt.close();

            pstmt = conn.prepareStatement(insertNetworkSql);
            int i = 1;
            pstmt.setLong(i++, seq);
            pstmt.setString(i++, name);
            pstmt.setString(i++, displayText);
            pstmt.setString(i++, trafficType);
            pstmt.setString(i++, broadcastDomainType);
            pstmt.setString(i++, gateway);
            pstmt.setString(i++, cidr);
            pstmt.setString(i++, mode);
            pstmt.setLong(i++, networkOfferingId);
            pstmt.setLong(i++, dataCenterId);
            pstmt.setString(i++, guruName);
            pstmt.setString(i++, state);
            pstmt.setLong(i++, domainId);
            pstmt.setLong(i++, accountId);
            pstmt.setString(i++, dns1);
            pstmt.setString(i++, dns2);
            pstmt.setString(i++, guestType);
            pstmt.setBoolean(i++, shared);
            pstmt.setBoolean(i++, isDefault);
            pstmt.setString(i++, networkDomain);
            pstmt.setLong(i++, seq);
            pstmt.setString(i++, reservationId);
            pstmt.setString(i++, broadcastUri);
            pstmt.executeUpdate();

            pstmt = conn.prepareStatement("INSERT INTO op_networks(id, mac_address_seq, nics_count, gc, check_for_gc) VALUES(?, ?, ?, ?, ?)");
            pstmt.setLong(1, seq);
            pstmt.setLong(2, 0);
            pstmt.setLong(3, 0);
            if (trafficType.equals("Guest")) {
                pstmt.setBoolean(4, true);
            } else {
                pstmt.setBoolean(4, false);
            }
            pstmt.setBoolean(5, false);
            pstmt.executeUpdate();

            pstmt = conn.prepareStatement("INSERT INTO account_network_ref (account_id, network_id, is_owner) VALUES (?,    ?,  1)");
            pstmt.setLong(1, accountId);
            pstmt.setLong(2, seq);
            pstmt.executeUpdate();

            return seq;
        } catch (SQLException e) {
            throw new CloudRuntimeException("Unable to create network", e);
        }
    }

    protected void upgradeManagementIpAddress(Connection conn, long dcId) throws SQLException {
        PreparedStatement pstmt = conn.prepareStatement("SELECT op_dc_ip_address_alloc.id FROM op_dc_ip_address_alloc WHERE data_center_id=?");
        pstmt.setLong(1, dcId);
        ResultSet rs = pstmt.executeQuery();
        ArrayList<Object[]> allocatedIps = new ArrayList<Object[]>();
        while (rs.next()) {
            Object[] ip = new Object[10];
            ip[0] = rs.getLong(1); // id
            allocatedIps.add(ip);
        }
        rs.close();
        pstmt.close();

        for (Object[] allocatedIp : allocatedIps) {
            pstmt = conn.prepareStatement("SELECT mac_address FROM data_center WHERE id = ?");
            pstmt.setLong(1, dcId);
            rs = pstmt.executeQuery();
            if (!rs.next()) {
                throw new CloudRuntimeException("Unable to get mac address for data center " + dcId);
            }
            long mac = rs.getLong(1);
            rs.close();
            pstmt.close();

            pstmt = conn.prepareStatement("UPDATE data_center SET mac_address=mac_address+1 WHERE id = ?");
            pstmt.setLong(1, dcId);
            pstmt.executeUpdate();
            pstmt.close();

            pstmt = conn.prepareStatement("UPDATE op_dc_ip_address_alloc SET mac_address=? WHERE id=?");
            pstmt.setLong(1, mac);
            pstmt.setLong(2, (Long)allocatedIp[0]);
            pstmt.executeUpdate();
            pstmt.close();
        }

    }

    protected void upgradeDirectUserIpAddress(Connection conn, long dcId, long networkId, String vlanType) throws SQLException {
        s_logger.debug("Upgrading user ip address for data center " + dcId + " network " + networkId + " vlan type " + vlanType);
        PreparedStatement pstmt =
            conn.prepareStatement("UPDATE user_ip_address INNER JOIN vlan ON user_ip_address.vlan_db_id=vlan.id SET user_ip_address.source_network_id=vlan.network_id WHERE user_ip_address.data_center_id=? AND vlan.vlan_type=?");
        pstmt.setLong(1, dcId);
        pstmt.setString(2, vlanType);
        pstmt.executeUpdate();
        pstmt.close();

        pstmt =
            conn.prepareStatement("SELECT user_ip_address.id, user_ip_address.public_ip_address, user_ip_address.account_id, user_ip_address.allocated FROM user_ip_address INNER JOIN vlan ON vlan.id=user_ip_address.vlan_db_id WHERE user_ip_address.data_center_id = ? AND vlan.vlan_type=?");
        pstmt.setLong(1, dcId);
        pstmt.setString(2, vlanType);
        ResultSet rs = pstmt.executeQuery();
        ArrayList<Object[]> allocatedIps = new ArrayList<Object[]>();
        while (rs.next()) {
            Object[] ip = new Object[10];
            ip[0] = rs.getLong(1); // id
            ip[1] = rs.getString(2); // ip address
            ip[2] = rs.getLong(3); // account id
            ip[3] = rs.getDate(4); // allocated
            allocatedIps.add(ip);
        }
        rs.close();
        pstmt.close();

        s_logger.debug("Marking " + allocatedIps.size() + " ip addresses to belong to network " + networkId);
        s_logger.debug("Updating mac addresses for data center id=" + dcId + ". Found " + allocatedIps.size() + " ip addresses to update");

        for (Object[] allocatedIp : allocatedIps) {
            pstmt = conn.prepareStatement("SELECT mac_address FROM data_center WHERE id = ?");
            pstmt.setLong(1, dcId);
            rs = pstmt.executeQuery();
            if (!rs.next()) {
                throw new CloudRuntimeException("Unable to get mac address for data center " + dcId);
            }
            long mac = rs.getLong(1);
            rs.close();
            pstmt.close();

            pstmt = conn.prepareStatement("UPDATE data_center SET mac_address=mac_address+1 WHERE id = ?");
            pstmt.setLong(1, dcId);
            pstmt.executeUpdate();
            pstmt.close();

            pstmt = conn.prepareStatement("UPDATE user_ip_address SET mac_address=? WHERE id=?");
            pstmt.setLong(1, mac);
            pstmt.setLong(2, (Long)allocatedIp[0]);
            pstmt.executeUpdate();
            pstmt.close();
        }
    }

    protected void upgradePublicUserIpAddress(Connection conn, long dcId, long networkId, String vlanType) throws SQLException {
        s_logger.debug("Upgrading user ip address for data center " + dcId + " network " + networkId + " vlan type " + vlanType);
        PreparedStatement pstmt =
            conn.prepareStatement("UPDATE user_ip_address INNER JOIN vlan ON user_ip_address.vlan_db_id=vlan.id SET source_network_id=? WHERE user_ip_address.data_center_id=? AND vlan.vlan_type=?");
        pstmt.setLong(1, networkId);
        pstmt.setLong(2, dcId);
        pstmt.setString(3, vlanType);
        pstmt.executeUpdate();
        pstmt.close();

        pstmt = conn.prepareStatement("UPDATE vlan SET network_id = ? WHERE data_center_id=? AND vlan_type=?");
        pstmt.setLong(1, networkId);
        pstmt.setLong(2, dcId);
        pstmt.setString(3, vlanType);
        pstmt.executeUpdate();
        pstmt.close();

        pstmt =
            conn.prepareStatement("SELECT user_ip_address.id, user_ip_address.public_ip_address, user_ip_address.account_id, user_ip_address.allocated FROM user_ip_address INNER JOIN vlan ON vlan.id=user_ip_address.vlan_db_id WHERE user_ip_address.data_center_id = ? AND vlan.vlan_type='VirtualNetwork'");
        pstmt.setLong(1, dcId);
        ResultSet rs = pstmt.executeQuery();
        ArrayList<Object[]> allocatedIps = new ArrayList<Object[]>();
        while (rs.next()) {
            Object[] ip = new Object[10];
            ip[0] = rs.getLong(1); // id
            ip[1] = rs.getString(2); // ip address
            ip[2] = rs.getLong(3); // account id
            ip[3] = rs.getDate(4); // allocated
            allocatedIps.add(ip);
        }
        rs.close();
        pstmt.close();

        for (Object[] allocatedIp : allocatedIps) {
            pstmt = conn.prepareStatement("SELECT mac_address FROM data_center WHERE id = ?");
            pstmt.setLong(1, dcId);
            rs = pstmt.executeQuery();
            if (!rs.next()) {
                throw new CloudRuntimeException("Unable to get mac address for data center " + dcId);
            }
            long mac = rs.getLong(1);
            rs.close();
            pstmt.close();

            pstmt = conn.prepareStatement("UPDATE data_center SET mac_address=mac_address+1 WHERE id = ?");
            pstmt.setLong(1, dcId);
            pstmt.executeUpdate();
            pstmt.close();

            Long associatedNetworkId = null;
            if (allocatedIp[3] != null && allocatedIp[2] != null) {
                pstmt = conn.prepareStatement("SELECT id FROM networks WHERE data_center_id=? AND account_id=?");
                pstmt.setLong(1, dcId);
                pstmt.setLong(2, (Long)allocatedIp[2]);
                rs = pstmt.executeQuery();
                if (!rs.next()) {
                    throw new CloudRuntimeException("Unable to find a network for account " + allocatedIp[2] + " in dc " + dcId);
                }
                associatedNetworkId = rs.getLong(1);
                rs.close();
                pstmt.close();
            }
            pstmt = conn.prepareStatement("UPDATE user_ip_address SET mac_address=?, network_id=? WHERE id=?");
            pstmt.setLong(1, mac);
            if (associatedNetworkId != null) {
                pstmt.setLong(2, associatedNetworkId);
            } else {
                pstmt.setObject(2, null);
            }
            pstmt.setLong(3, (Long)allocatedIp[0]);
            pstmt.executeUpdate();
            pstmt.close();
        }

    }

    protected void upgradeDataCenter(Connection conn) {
        PreparedStatement pstmt;
        try {
            pstmt = conn.prepareStatement("SELECT value FROM configuration WHERE name='direct.attach.untagged.vlan.enabled'");
            ResultSet rs = pstmt.executeQuery();
            _basicZone = !rs.next() || Boolean.parseBoolean(rs.getString(1));
            rs.close();
            pstmt.close();
            pstmt =
                conn.prepareStatement("UPDATE data_center SET networktype=?, dns_provider=?, gateway_provider=?, firewall_provider=?, dhcp_provider=?, lb_provider=?, vpn_provider=?, userdata_provider=?");
            if (_basicZone) {
                pstmt.setString(1, "Basic");
                pstmt.setString(2, "DhcpServer");
                pstmt.setString(3, null);
                pstmt.setString(4, null);
                pstmt.setString(5, "DhcpServer");
                pstmt.setString(6, null);
                pstmt.setString(7, null);
                pstmt.setString(8, "DhcpServer");
            } else {
                pstmt.setString(1, "Advanced");
                pstmt.setString(2, "VirtualRouter");
                pstmt.setString(3, "VirtualRouter");
                pstmt.setString(4, "VirtualRouter");
                pstmt.setString(5, "VirtualRouter");
                pstmt.setString(6, "VirtualRouter");
                pstmt.setString(7, "VirtualRouter");
                pstmt.setString(8, "VirtualRouter");
            }
            pstmt.executeUpdate();
            pstmt.close();

            // For basic zone vnet field should be NULL

            if (_basicZone) {
                pstmt = conn.prepareStatement("UPDATE data_center SET vnet=?, guest_network_cidr=?");
                pstmt.setString(1, null);
                pstmt.setString(2, null);
                pstmt.executeUpdate();
                pstmt.close();
            }

            pstmt = conn.prepareStatement("SELECT id, guest_network_cidr, domain FROM data_center");
            rs = pstmt.executeQuery();
            ArrayList<Object[]> dcs = new ArrayList<Object[]>();
            while (rs.next()) {
                Object[] dc = new Object[10];
                dc[0] = rs.getLong(1); // data center id
                dc[1] = rs.getString(2); // guest network cidr
                dc[2] = rs.getString(3); // network domain
                dcs.add(dc);
            }
            rs.close();
            pstmt.close();

            pstmt = conn.prepareStatement("SELECT id FROM network_offerings WHERE name='System-Management-Network'");
            rs = pstmt.executeQuery();
            if (!rs.next()) {
                s_logger.error("Unable to find the management network offering.");
                throw new CloudRuntimeException("Unable to find the management network offering.");
            }
            long managementNetworkOfferingId = rs.getLong(1);
            rs.close();
            pstmt.close();

            pstmt = conn.prepareStatement("SELECT id FROM network_offerings WHERE name='System-Public-Network'");
            rs = pstmt.executeQuery();
            if (!rs.next()) {
                s_logger.error("Unable to find the public network offering.");
                throw new CloudRuntimeException("Unable to find the public network offering.");
            }
            long publicNetworkOfferingId = rs.getLong(1);
            rs.close();
            pstmt.close();

            pstmt = conn.prepareStatement("SELECT id FROM network_offerings WHERE name='System-Control-Network'");
            rs = pstmt.executeQuery();
            if (!rs.next()) {
                s_logger.error("Unable to find the control network offering.");
                throw new CloudRuntimeException("Unable to find the control network offering.");
            }
            long controlNetworkOfferingId = rs.getLong(1);
            rs.close();
            pstmt.close();

            pstmt = conn.prepareStatement("SELECT id FROM network_offerings WHERE name='System-Storage-Network'");
            rs = pstmt.executeQuery();
            if (!rs.next()) {
                s_logger.error("Unable to find the storage network offering.");
                throw new CloudRuntimeException("Unable to find the storage network offering.");
            }
            long storageNetworkOfferingId = rs.getLong(1);
            rs.close();
            pstmt.close();

            if (_basicZone) {
                for (Object[] dc : dcs) {
                    Long dcId = (Long)dc[0];
                    long mgmtNetworkId =
                        insertNetwork(conn, "ManagementNetwork" + dcId, "Management Network created for Zone " + dcId, "Management", "Native", null, null, null,
                            "Static", managementNetworkOfferingId, dcId, "PodBasedNetworkGuru", "Setup", 1, 1, null, null, null, true, null, false, null);
                    long storageNetworkId =
                        insertNetwork(conn, "StorageNetwork" + dcId, "Storage Network created for Zone " + dcId, "Storage", "Native", null, null, null, "Static",
                            storageNetworkOfferingId, dcId, "PodBasedNetworkGuru", "Setup", 1, 1, null, null, null, true, null, false, null);
                    long controlNetworkId =
                        insertNetwork(conn, "ControlNetwork" + dcId, "Control Network created for Zone " + dcId, "Control", "LinkLocal", null,
                            NetUtils.getLinkLocalGateway(), NetUtils.getLinkLocalCIDR(), "Static", controlNetworkOfferingId, dcId, "ControlNetworkGuru", "Setup", 1, 1,
                            null, null, null, true, null, false, null);
                    upgradeManagementIpAddress(conn, dcId);
                    long basicDefaultDirectNetworkId =
                        insertNetwork(conn, "BasicZoneDirectNetwork" + dcId, "Basic Zone Direct Network created for Zone " + dcId, "Guest", "Native", null, null, null,
                            "Dhcp", 5, dcId, "DirectPodBasedNetworkGuru", "Setup", 1, 1, null, null, "Direct", true, null, true, null);

                    pstmt = conn.prepareStatement("SELECT id FROM vlan WHERE vlan_type='DirectAttached' AND data_center_id=?");
                    pstmt.setLong(1, dcId);
                    rs = pstmt.executeQuery();
                    while (rs.next()) {
                        long vlanId = rs.getLong(1);

                        pstmt = conn.prepareStatement("UPDATE vlan SET network_id=? WHERE id=?");
                        pstmt.setLong(1, basicDefaultDirectNetworkId);
                        pstmt.setLong(2, vlanId);
                        pstmt.executeUpdate();
                        pstmt.close();
                    }

                    upgradeDirectUserIpAddress(conn, dcId, basicDefaultDirectNetworkId, "DirectAttached");

                    // update Dhcp servers information in domain_router and vm_instance tables; all domRs belong to the same
                    // network
                    pstmt =
                        conn.prepareStatement("SELECT vm_instance.id, vm_instance.domain_id, vm_instance.account_id, domain_router.gateway, domain_router.guest_ip_address, domain_router.domain, domain_router.dns1, domain_router.dns2, domain_router.vnet FROM vm_instance INNER JOIN domain_router ON vm_instance.id=domain_router.id WHERE vm_instance.removed IS NULL AND vm_instance.type='DomainRouter' AND vm_instance.data_center_id=?");
                    pstmt.setLong(1, dcId);
                    rs = pstmt.executeQuery();
                    ArrayList<Object[]> routers = new ArrayList<Object[]>();
                    while (rs.next()) {
                        Object[] router = new Object[40];
                        router[0] = rs.getLong(1); // router id
                        router[1] = rs.getString(4); // router gateway which is gonna be gateway for user vms
                        routers.add(router);
                    }
                    rs.close();
                    pstmt.close();

                    for (Object[] router : routers) {
                        s_logger.debug("Updating domR with network id in basic zone id=" + dcId);
                        pstmt = conn.prepareStatement("UPDATE domain_router SET network_id = ? wHERE id = ? ");
                        pstmt.setLong(1, basicDefaultDirectNetworkId);
                        pstmt.setLong(2, (Long)router[0]);
                        pstmt.executeUpdate();
                        pstmt.close();

                        upgradeUserVms(conn, (Long)router[0], basicDefaultDirectNetworkId, (String)router[1], "untagged", "DirectPodBasedNetworkGuru", "Create");
                        upgradeDomR(conn, dcId, (Long)router[0], null, basicDefaultDirectNetworkId, controlNetworkId, "Basic", "untagged");
                    }

                    upgradeSsvm(conn, dcId, basicDefaultDirectNetworkId, mgmtNetworkId, controlNetworkId, "Basic");

                    pstmt = conn.prepareStatement("SELECT vm_instance.id FROM vm_instance WHERE removed IS NULL AND type='ConsoleProxy' AND data_center_id=?");
                    pstmt.setLong(1, dcId);
                    rs = pstmt.executeQuery();
                    while (rs.next()) {
                        upgradeConsoleProxy(conn, dcId, rs.getLong(1), basicDefaultDirectNetworkId, mgmtNetworkId, controlNetworkId, "Basic");
                    }

                }
            } else {
                for (Object[] dc : dcs) {
                    Long dcId = (Long)dc[0];
                    long mgmtNetworkId =
                        insertNetwork(conn, "ManagementNetwork" + dcId, "Management Network created for Zone " + dcId, "Management", "Native", null, null, null,
                            "Static", managementNetworkOfferingId, dcId, "PodBasedNetworkGuru", "Setup", 1, 1, null, null, null, true, null, false, null);
                    insertNetwork(conn, "StorageNetwork" + dcId, "Storage Network created for Zone " + dcId, "Storage", "Native", null, null, null, "Static",
                        storageNetworkOfferingId, dcId, "PodBasedNetworkGuru", "Setup", 1, 1, null, null, null, true, null, false, null);
                    long controlNetworkId =
                        insertNetwork(conn, "ControlNetwork" + dcId, "Control Network created for Zone " + dcId, "Control", "Native", null, null, null, "Static",
                            controlNetworkOfferingId, dcId, "ControlNetworkGuru", "Setup", 1, 1, null, null, null, true, null, false, null);
                    upgradeManagementIpAddress(conn, dcId);
                    long publicNetworkId =
                        insertNetwork(conn, "PublicNetwork" + dcId, "Public Network Created for Zone " + dcId, "Public", "Vlan", null, null, null, "Static",
                            publicNetworkOfferingId, dcId, "PublicNetworkGuru", "Setup", 1, 1, null, null, null, true, null, false, null);

                    pstmt =
                        conn.prepareStatement("SELECT vm_instance.id, vm_instance.domain_id, vm_instance.account_id, domain_router.guest_ip_address, domain_router.domain, domain_router.dns1, domain_router.dns2, domain_router.vnet FROM vm_instance INNER JOIN domain_router ON vm_instance.id=domain_router.id WHERE vm_instance.removed IS NULL AND vm_instance.type='DomainRouter' AND vm_instance.data_center_id=? and domain_router.role='DHCP_FIREWALL_LB_PASSWD_USERDATA'");
                    pstmt.setLong(1, dcId);
                    rs = pstmt.executeQuery();
                    ArrayList<Object[]> routers = new ArrayList<Object[]>();
                    while (rs.next()) {
                        Object[] router = new Object[40];
                        router[0] = rs.getLong(1); // router id
                        router[1] = rs.getLong(2); // domain id
                        router[2] = rs.getLong(3); // account id
                        router[3] = rs.getString(4); // guest ip which becomes the gateway in network
                        router[4] = rs.getString(5); // domain name
                        router[5] = rs.getString(6); // dns1
                        router[6] = rs.getString(7); // dns2
                        router[7] = rs.getString(8); // vnet
                        routers.add(router);
                    }
                    rs.close();
                    pstmt.close();

                    for (Object[] router : routers) {
                        String vnet = (String)router[7];
                        String reservationId = null;
                        String state = "Allocated";
                        if (vnet != null) {
                            reservationId = dcId + "-" + vnet;
                            state = "Implemented";
                        }

                        String vlan = null;
                        if (vnet != null) {
                            vlan = "vlan://" + vnet;
                        }

                        long virtualNetworkId =
                            insertNetwork(conn, "VirtualNetwork" + router[0], "Virtual Network for " + router[0], "Guest", "Vlan", vlan, (String)router[3],
                                (String)dc[1], "Dhcp", 6, dcId, "ExternalGuestNetworkGuru", state, (Long)router[1], (Long)router[2], (String)router[5],
                                (String)router[6], "Virtual", false, (String)router[4], true, reservationId);
                        pstmt = conn.prepareStatement("UPDATE domain_router SET network_id = ? wHERE id = ? ");
                        pstmt.setLong(1, virtualNetworkId);
                        pstmt.setLong(2, (Long)router[0]);
                        pstmt.executeUpdate();
                        pstmt.close();
                        s_logger.debug("Network inserted for " + router[0] + " id = " + virtualNetworkId);

                        upgradeUserVms(conn, (Long)router[0], virtualNetworkId, (String)router[3], vnet, "ExternalGuestNetworkGuru", "Start");
                        upgradeDomR(conn, dcId, (Long)router[0], publicNetworkId, virtualNetworkId, controlNetworkId, "Advanced", vnet);
                    }

                    upgradePublicUserIpAddress(conn, dcId, publicNetworkId, "VirtualNetwork");

                    // Create direct networks
                    pstmt = conn.prepareStatement("SELECT id, vlan_id, vlan_gateway, vlan_netmask FROM vlan WHERE vlan_type='DirectAttached' AND data_center_id=?");
                    pstmt.setLong(1, dcId);
                    rs = pstmt.executeQuery();
                    HashMap<String, Long> vlanNetworkMap = new HashMap<String, Long>();
                    while (rs.next()) {
                        long vlanId = rs.getLong(1);
                        String tag = rs.getString(2);
                        String gateway = rs.getString(3);
                        String netmask = rs.getString(4);
                        String cidr = NetUtils.getCidrFromGatewayAndNetmask(gateway, netmask);

                        // Get the owner of the network
                        Long accountId = 1L;
                        Long domainId = 1L;
                        boolean isShared = true;
                        pstmt = conn.prepareStatement("SELECT account_id FROM account_vlan_map WHERE account_id IS NOT NULL AND vlan_db_id=?");
                        pstmt.setLong(1, vlanId);
                        ResultSet accountRs = pstmt.executeQuery();
                        while (accountRs.next()) {
                            isShared = false;
                            accountId = accountRs.getLong(1);
                            pstmt = conn.prepareStatement("SELECT domain_id FROM account WHERE id=?");
                            pstmt.setLong(1, accountId);
                            ResultSet domainRs = pstmt.executeQuery();
                            while (domainRs.next()) {
                                domainId = domainRs.getLong(1);
                            }
                        }

                        if (vlanNetworkMap.get(tag) == null) {
                            long directNetworkId =
                                insertNetwork(conn, "DirectNetwork" + vlanId, "Direct network created for " + vlanId, "Guest", "Vlan", "vlan://" + tag, gateway, cidr,
                                    "Dhcp", 7, dcId, "DirectNetworkGuru", "Setup", domainId, accountId, null, null, "Direct", isShared, (String)dc[2], true, null);
                            vlanNetworkMap.put(tag, directNetworkId);
                        }

                        pstmt = conn.prepareStatement("UPDATE vlan SET network_id=? WHERE id=?");
                        pstmt.setLong(1, vlanNetworkMap.get(tag));
                        pstmt.setLong(2, vlanId);
                        pstmt.executeUpdate();

                        pstmt.close();

                        upgradeDirectUserIpAddress(conn, dcId, vlanNetworkMap.get(tag), "DirectAttached");
                        s_logger.debug("Created Direct networks and upgraded Direct ip addresses");
                    }

                    // Create DHCP domRs - Direct networks
                    pstmt =
                        conn.prepareStatement("SELECT vm_instance.id, domain_router.guest_ip_address FROM vm_instance INNER JOIN domain_router ON vm_instance.id=domain_router.id WHERE vm_instance.removed IS NULL AND vm_instance.type='DomainRouter' AND vm_instance.data_center_id=? and domain_router.role='DHCP_USERDATA'");
                    pstmt.setLong(1, dcId);
                    rs = pstmt.executeQuery();
                    ArrayList<Object[]> dhcpServers = new ArrayList<Object[]>();
                    while (rs.next()) {
                        Object[] dhcpServer = new Object[40];
                        dhcpServer[0] = rs.getLong(1); // router id
                        dhcpServer[1] = rs.getString(2); // guest IP address - direct ip address of the domR
                        dhcpServers.add(dhcpServer);
                    }
                    rs.close();
                    pstmt.close();

                    for (Object[] dhcpServer : dhcpServers) {
                        Long routerId = (Long)dhcpServer[0];
                        String directIp = (String)dhcpServer[1];

                        pstmt =
                            conn.prepareStatement("SELECT u.source_network_id, v.vlan_id from user_ip_address u, vlan v where u.public_ip_address=? and v.id=u.vlan_db_id");
                        pstmt.setString(1, directIp);
                        rs = pstmt.executeQuery();
                        if (!rs.next()) {
                            throw new CloudRuntimeException("Unable to find Direct ip address " + directIp + " in user_ip_address table");
                        }

                        Long directNetworkId = rs.getLong(1);
                        String vnet = rs.getString(2);
                        rs.close();

                        pstmt = conn.prepareStatement("SELECT gateway from networks where id=?");
                        pstmt.setLong(1, directNetworkId);
                        rs = pstmt.executeQuery();
                        if (!rs.next()) {
                            throw new CloudRuntimeException("Unable to find gateway for network id=" + directNetworkId);
                        }

                        String gateway = rs.getString(1);
                        rs.close();

                        pstmt = conn.prepareStatement("UPDATE domain_router SET network_id = ? wHERE id = ? ");
                        pstmt.setLong(1, directNetworkId);
                        pstmt.setLong(2, routerId);
                        pstmt.executeUpdate();
                        pstmt.close();
                        s_logger.debug("NetworkId updated for router id=" + routerId + "with network id = " + directNetworkId);

                        upgradeUserVms(conn, routerId, directNetworkId, gateway, vnet, "DirectNetworkGuru", "Create");
                        s_logger.debug("Upgraded Direct vms in Advance zone id=" + dcId);
                        upgradeDomR(conn, dcId, routerId, null, directNetworkId, controlNetworkId, "Advanced", vnet);
                        s_logger.debug("Upgraded Direct domRs in Advance zone id=" + dcId);
                    }

                    // Upgrade SSVM
                    upgradeSsvm(conn, dcId, publicNetworkId, mgmtNetworkId, controlNetworkId, "Advanced");

                    // Upgrade ConsoleProxy
                    pstmt = conn.prepareStatement("SELECT vm_instance.id FROM vm_instance WHERE removed IS NULL AND type='ConsoleProxy' AND data_center_id=?");
                    pstmt.setLong(1, dcId);
                    rs = pstmt.executeQuery();
                    while (rs.next()) {
                        upgradeConsoleProxy(conn, dcId, rs.getLong(1), publicNetworkId, mgmtNetworkId, controlNetworkId, "Advanced");
                    }
                    pstmt.close();
                }
            }

        } catch (SQLException e) {
            s_logger.error("Can't update data center ", e);
            throw new CloudRuntimeException("Can't update data center ", e);
        }
    }

    private void updateUserStats(Connection conn) {
        try {

            // update device_type information
            PreparedStatement pstmt = conn.prepareStatement("UPDATE user_statistics SET device_type='DomainRouter'");
            pstmt.executeUpdate();
            pstmt.close();
            s_logger.debug("Upgraded userStatistcis with device_type=DomainRouter");

            // update device_id infrormation
            pstmt = conn.prepareStatement("SELECT id, account_id, data_center_id FROM user_statistics");
            ResultSet rs = pstmt.executeQuery();

            while (rs.next()) {
                Long id = rs.getLong(1); // user stats id
                Long accountId = rs.getLong(2); // account id
                Long dataCenterId = rs.getLong(3); // zone id

                pstmt = conn.prepareStatement("SELECT networktype from data_center where id=?");
                pstmt.setLong(1, dataCenterId);

                ResultSet dcSet = pstmt.executeQuery();

                if (!dcSet.next()) {
                    s_logger.error("Unable to get data_center information as a part of user_statistics update");
                    throw new CloudRuntimeException("Unable to get data_center information as a part of user_statistics update");
                }

                String dataCenterType = dcSet.getString(1);

                if (dataCenterType.equalsIgnoreCase("basic")) {
                    accountId = 1L;
                }

                pstmt = conn.prepareStatement("SELECT id from vm_instance where account_id=? AND data_center_id=? AND type='DomainRouter'");
                pstmt.setLong(1, accountId);
                pstmt.setLong(2, dataCenterId);
                ResultSet rs1 = pstmt.executeQuery();

                Long deviceId = 0L;
                if (!rs1.next()) {
                    // check if there are any non-removed user vms existing for this account
                    // if all vms are expunged, and there is no domR, just skip this record
                    pstmt = conn.prepareStatement("SELECT * from vm_instance where account_id=? AND data_center_id=? AND removed IS NULL");
                    pstmt.setLong(1, accountId);
                    pstmt.setLong(2, dataCenterId);
                    ResultSet nonRemovedVms = pstmt.executeQuery();

                    if (nonRemovedVms.next()) {
                        s_logger.warn("Failed to find domR for for account id=" + accountId + " in zone id=" + dataCenterId +
                            "; will try to locate domR based on user_vm info");
                        //try to get domR information from the user_vm belonging to the account
                        pstmt =
                            conn.prepareStatement("SELECT u.domain_router_id from user_vm u, vm_instance v where u.account_id=? AND v.data_center_id=? AND v.removed IS NULL AND u.domain_router_id is NOT NULL");
                        pstmt.setLong(1, accountId);
                        pstmt.setLong(2, dataCenterId);
                        ResultSet userVmSet = pstmt.executeQuery();
                        if (!userVmSet.next()) {
                            s_logger.warn("Skipping user_statistics upgrade for account id=" + accountId + " in datacenter id=" + dataCenterId);
                            continue;
                        }
                        deviceId = userVmSet.getLong(1);
                    } else {
                        s_logger.debug("Account id=" + accountId + " doesn't own any user vms and domRs, so skipping user_statistics update");
                        continue;
                    }
                } else {
                    deviceId = rs1.getLong(1);
                }

                pstmt = conn.prepareStatement("UPDATE user_statistics SET device_id=? where id=?");
                pstmt.setLong(1, deviceId);
                pstmt.setLong(2, id);
                pstmt.executeUpdate();

                pstmt = conn.prepareStatement("");

            }
            s_logger.debug("Upgraded userStatistcis with deviceId(s)");

        } catch (Exception e) {
            throw new CloudRuntimeException("Failed to migrate usage events: ", e);
        }
    }

    public void upgradePortForwardingRules(Connection conn) {
        try {
            PreparedStatement pstmt =
                conn.prepareStatement("SELECT id, public_ip_address, public_port, private_ip_address, private_port, protocol FROM ip_forwarding WHERE forwarding=1");
            ResultSet rs = pstmt.executeQuery();
            ArrayList<Object[]> rules = new ArrayList<Object[]>();
            while (rs.next()) {
                Object[] rule = new Object[10];
                rule[0] = rs.getLong(1); // rule id
                rule[1] = rs.getString(2); // rule public IP
                rule[2] = rs.getString(3); // rule public port
                rule[3] = rs.getString(4); // rule private Ip
                rule[4] = rs.getString(5); // rule private port
                rule[5] = rs.getString(6); // rule protocol
                rules.add(rule);
            }
            rs.close();
            pstmt.close();

            if (!rules.isEmpty()) {
                s_logger.debug("Found " + rules.size() + " port forwarding rules to upgrade");
                for (Object[] rule : rules) {
                    long id = (Long)rule[0];
                    String sourcePort = (String)rule[2];
                    String protocol = (String)rule[5];
                    String publicIp = (String)rule[1];

                    pstmt = conn.prepareStatement("SELECT id, account_id, domain_id, network_id FROM user_ip_address WHERE public_ip_address=?");
                    pstmt.setString(1, publicIp);
                    rs = pstmt.executeQuery();

                    if (!rs.next()) {
                        s_logger.error("Unable to find public IP address " + publicIp);
                        throw new CloudRuntimeException("Unable to find public IP address " + publicIp);
                    }

                    int ipAddressId = rs.getInt(1);
                    long accountId = rs.getLong(2);
                    long domainId = rs.getLong(3);
                    long networkId = rs.getLong(4);
                    String privateIp = (String)rule[3];

                    rs.close();
                    pstmt.close();

                    // update port_forwarding_rules table
                    s_logger.trace("Updating port_forwarding_rules table...");
                    pstmt = conn.prepareStatement("SELECT instance_id FROM nics where network_id=? AND ip4_address=?");
                    pstmt.setLong(1, networkId);
                    pstmt.setString(2, privateIp);
                    rs = pstmt.executeQuery();

                    if (!rs.next()) {
                        // the vm might be expunged already...so just give the warning
                        s_logger.warn("Unable to find vmId for private ip address " + privateIp + " for account id=" + accountId + "; assume that the vm is expunged");
                        // throw new CloudRuntimeException("Unable to find vmId for private ip address " + privateIp +
                        // " for account id=" + accountId);
                    } else {
                        long instanceId = rs.getLong(1);
                        s_logger.debug("Instance id is " + instanceId);
                        // update firewall_rules table
                        s_logger.trace("Updating firewall_rules table as a part of PF rules upgrade...");
                        pstmt =
                            conn.prepareStatement("INSERT INTO firewall_rules (id, ip_address_id, start_port, end_port, state, protocol, purpose, account_id, domain_id, network_id, xid, is_static_nat, created) VALUES (?,    ?,      ?,      ?,      'Active',        ?,     'PortForwarding',       ?,      ?,      ?,      ?,       0,     now())");
                        pstmt.setLong(1, id);
                        pstmt.setInt(2, ipAddressId);
                        pstmt.setInt(3, Integer.valueOf(sourcePort.trim()));
                        pstmt.setInt(4, Integer.valueOf(sourcePort.trim()));
                        pstmt.setString(5, protocol);
                        pstmt.setLong(6, accountId);
                        pstmt.setLong(7, domainId);
                        pstmt.setLong(8, networkId);
                        pstmt.setString(9, UUID.randomUUID().toString());
                        pstmt.executeUpdate();
                        pstmt.close();
                        s_logger.trace("firewall_rules table is updated as a part of PF rules upgrade");

                        rs.close();
                        pstmt.close();

                        String privatePort = (String)rule[4];
                        pstmt = conn.prepareStatement("INSERT INTO port_forwarding_rules VALUES (?,    ?,      ?,      ?,       ?)");
                        pstmt.setLong(1, id);
                        pstmt.setLong(2, instanceId);
                        pstmt.setString(3, privateIp);
                        pstmt.setInt(4, Integer.valueOf(privatePort.trim()));
                        pstmt.setInt(5, Integer.valueOf(privatePort.trim()));
                        pstmt.executeUpdate();
                        pstmt.close();
                        s_logger.trace("port_forwarding_rules table is updated");

                    }

                }
            }
            s_logger.debug("Port forwarding rules are updated");
        } catch (SQLException e) {
            throw new CloudRuntimeException("Can't update port forwarding rules ", e);
        }
    }

    public void upgradeLoadBalancingRules(Connection conn) {
        try {
            PreparedStatement pstmt = conn.prepareStatement("SELECT name, ip_address, public_port, private_port, algorithm, id FROM load_balancer");
            ResultSet rs = pstmt.executeQuery();
            ArrayList<Object[]> lbs = new ArrayList<Object[]>();
            while (rs.next()) {
                Object[] lb = new Object[10];
                lb[0] = rs.getString(1); // lb name
                lb[1] = rs.getString(2); // lb public IP
                lb[2] = rs.getString(3); // lb public port
                lb[3] = rs.getString(4); // lb private port
                lb[4] = rs.getString(5); // lb algorithm
                lb[5] = rs.getLong(6); // lb Id
                lbs.add(lb);
            }
            rs.close();
            pstmt.close();

            if (!lbs.isEmpty()) {
                s_logger.debug("Found " + lbs.size() + " lb rules to upgrade");
                pstmt = conn.prepareStatement("SELECT id FROM firewall_rules order by id");
                rs = pstmt.executeQuery();
                long newLbId = 0;
                while (rs.next()) {
                    newLbId = rs.getLong(1);
                }
                rs.close();
                pstmt.close();

                for (Object[] lb : lbs) {
                    String name = (String)lb[0];
                    String publicIp = (String)lb[1];
                    String sourcePort = (String)lb[2];
                    String destPort = (String)lb[3];
                    String algorithm = (String)lb[4];
                    Long originalLbId = (Long)lb[5];
                    newLbId = newLbId + 1;

                    pstmt = conn.prepareStatement("SELECT id, account_id, domain_id, network_id FROM user_ip_address WHERE public_ip_address=?");
                    pstmt.setString(1, publicIp);
                    rs = pstmt.executeQuery();

                    if (!rs.next()) {
                        s_logger.warn("Unable to find public IP address " + publicIp + "; skipping lb rule id=" + originalLbId +
                            " from update. Cleaning it up from load_balancer_vm_map and load_balancer table");
                        pstmt = conn.prepareStatement("DELETE from load_balancer_vm_map where load_balancer_id=?");
                        pstmt.setLong(1, originalLbId);
                        pstmt.executeUpdate();

                        pstmt = conn.prepareStatement("DELETE from load_balancer where id=?");
                        pstmt.setLong(1, originalLbId);
                        pstmt.executeUpdate();

                        continue;
                    }

                    int ipAddressId = rs.getInt(1);
                    long accountId = rs.getLong(2);
                    long domainId = rs.getLong(3);
                    long networkId = rs.getLong(4);

                    rs.close();
                    pstmt.close();

                    // update firewall_rules table
                    s_logger.trace("Updating firewall_rules table as a part of LB rules upgrade...");
                    pstmt =
                        conn.prepareStatement("INSERT INTO firewall_rules (id, ip_address_id, start_port, end_port, state, protocol, purpose, account_id, domain_id, network_id, xid, is_static_nat, created) VALUES (?,    ?,      ?,      ?,      'Active',        ?,     'LoadBalancing',       ?,      ?,      ?,      ?,       0,       now())");
                    pstmt.setLong(1, newLbId);
                    pstmt.setInt(2, ipAddressId);
                    pstmt.setInt(3, Integer.valueOf(sourcePort));
                    pstmt.setInt(4, Integer.valueOf(sourcePort));
                    pstmt.setString(5, "tcp");
                    pstmt.setLong(6, accountId);
                    pstmt.setLong(7, domainId);
                    pstmt.setLong(8, networkId);
                    pstmt.setString(9, UUID.randomUUID().toString());
                    pstmt.executeUpdate();
                    pstmt.close();
                    s_logger.trace("firewall_rules table is updated as a part of LB rules upgrade");

                    // update load_balancing_rules
                    s_logger.trace("Updating load_balancing_rules table as a part of LB rules upgrade...");
                    pstmt = conn.prepareStatement("INSERT INTO load_balancing_rules VALUES (?,      ?,      NULL,      ?,       ?,      ?)");
                    pstmt.setLong(1, newLbId);
                    pstmt.setString(2, name);
                    pstmt.setInt(3, Integer.valueOf(destPort));
                    pstmt.setInt(4, Integer.valueOf(destPort));
                    pstmt.setString(5, algorithm);
                    pstmt.executeUpdate();
                    pstmt.close();
                    s_logger.trace("load_balancing_rules table is updated as a part of LB rules upgrade");

                    // update load_balancer_vm_map table
                    s_logger.trace("Updating load_balancer_vm_map table as a part of LB rules upgrade...");
                    pstmt = conn.prepareStatement("SELECT instance_id FROM load_balancer_vm_map WHERE load_balancer_id=?");
                    pstmt.setLong(1, originalLbId);
                    rs = pstmt.executeQuery();
                    ArrayList<Object[]> lbMaps = new ArrayList<Object[]>();
                    while (rs.next()) {
                        Object[] lbMap = new Object[10];
                        lbMap[0] = rs.getLong(1); // instanceId
                        lbMaps.add(lbMap);
                    }
                    rs.close();
                    pstmt.close();

                    pstmt = conn.prepareStatement("UPDATE load_balancer_vm_map SET load_balancer_id=? WHERE load_balancer_id=?");
                    pstmt.setLong(1, newLbId);
                    pstmt.setLong(2, originalLbId);
                    pstmt.executeUpdate();
                    pstmt.close();

                    s_logger.trace("load_balancer_vm_map table is updated as a part of LB rules upgrade");
                }
            }
            s_logger.debug("LB rules are upgraded");
        } catch (SQLException e) {
            throw new CloudRuntimeException("Can't update LB rules ", e);
        }
    }

    private void upgradeHostMemoryCapacityInfo(Connection conn) {
        try {
            // count user_vm memory info (M Bytes)
            PreparedStatement pstmt =
                conn.prepareStatement("select h.id, sum(s.ram_size) from host h, vm_instance v, service_offering s where h.type='Routing' and v.state='Running' and v.`type`='User' and v.host_id=h.id  and v.service_offering_id = s.id group by h.id");

            ResultSet rs = pstmt.executeQuery();
            Map<Long, Long> hostUsedMemoryInfo = new HashMap<Long, Long>();
            while (rs.next()) {
                hostUsedMemoryInfo.put(rs.getLong(1), rs.getLong(2));
            }
            rs.close();
            pstmt.close();

            int proxyRamSize = NumbersUtil.parseInt(getConfigValue(conn, "consoleproxy.ram.size"), 1024); // ConsoleProxyManager.DEFAULT_PROXY_VM_RAMSIZE);
            int domrRamSize = NumbersUtil.parseInt(getConfigValue(conn, "router.ram.size"), 128); // VpcVirtualNetworkApplianceManager.DEFAULT_ROUTER_VM_RAMSIZE);
            int ssvmRamSize = NumbersUtil.parseInt(getConfigValue(conn, "secstorage.vm.ram.size"), 256); // SecondaryStorageVmManager.DEFAULT_SS_VM_RAMSIZE);

            pstmt =
                conn.prepareStatement("select h.id, count(v.id) from host h, vm_instance v where h.type='Routing' and v.state='Running' and v.`type`='ConsoleProxy' and v.host_id=h.id group by h.id");
            rs = pstmt.executeQuery();
            while (rs.next()) {
                if (hostUsedMemoryInfo.get(rs.getLong(1)) != null) {
                    Long usedMem = hostUsedMemoryInfo.get(rs.getLong(1));
                    hostUsedMemoryInfo.put(rs.getLong(1), rs.getLong(2) * proxyRamSize + usedMem);
                } else {
                    hostUsedMemoryInfo.put(rs.getLong(1), rs.getLong(2) * proxyRamSize);
                }
            }
            rs.close();
            pstmt.close();

            pstmt =
                conn.prepareStatement("select h.id, count(v.id) from host h, vm_instance v where h.type='Routing' and v.state='Running' and v.`type`='DomainRouter' and v.host_id=h.id group by h.id");
            rs = pstmt.executeQuery();
            while (rs.next()) {
                if (hostUsedMemoryInfo.get(rs.getLong(1)) != null) {
                    Long usedMem = hostUsedMemoryInfo.get(rs.getLong(1));
                    hostUsedMemoryInfo.put(rs.getLong(1), rs.getLong(2) * domrRamSize + usedMem);
                } else {
                    hostUsedMemoryInfo.put(rs.getLong(1), rs.getLong(2) * domrRamSize);
                }
            }
            rs.close();
            pstmt.close();

            pstmt =
                conn.prepareStatement("select h.id, count(v.id) from host h, vm_instance v where h.type='Routing' and v.state='Running' and v.`type`='SecondaryStorageVm' and v.host_id=h.id group by h.id");
            rs = pstmt.executeQuery();
            while (rs.next()) {
                if (hostUsedMemoryInfo.get(rs.getLong(1)) != null) {
                    Long usedMem = hostUsedMemoryInfo.get(rs.getLong(1));
                    hostUsedMemoryInfo.put(rs.getLong(1), rs.getLong(2) * ssvmRamSize + usedMem);
                } else {
                    hostUsedMemoryInfo.put(rs.getLong(1), rs.getLong(2) * ssvmRamSize);
                }
            }
            rs.close();
            pstmt.close();

            for (Map.Entry<Long, Long> entry : hostUsedMemoryInfo.entrySet()) {
                pstmt = conn.prepareStatement("update op_host_capacity set used_capacity=? where host_id=? and capacity_type=0");
                pstmt.setLong(1, entry.getValue() * 1024 * 1024);
                pstmt.setLong(2, entry.getKey());

                pstmt.executeUpdate();
            }

        } catch (SQLException e) {
            throw new CloudRuntimeException("Can't upgrade host capacity info ", e);
        }
    }

    // per domain resource counts is introduced from 2.2 so we need to evaluate the domain limits
    // from the resource counts of account, and account-domain relation for all resource types
    private void upgradeDomainResourceCounts(Connection conn) {
        upgradeDomainResourceCounts(conn, ResourceType.volume);
        upgradeDomainResourceCounts(conn, ResourceType.user_vm);
        upgradeDomainResourceCounts(conn, ResourceType.snapshot);
        upgradeDomainResourceCounts(conn, ResourceType.template);
        upgradeDomainResourceCounts(conn, ResourceType.public_ip);
    }

    public static void upgradeDomainResourceCounts(Connection conn, ResourceType resourceType) {
        try {

            PreparedStatement account_count_pstmt = conn.prepareStatement("SELECT account_id, count from resource_count where type='" + resourceType + "'");
            ResultSet rs_account_count = account_count_pstmt.executeQuery();

            while (rs_account_count.next()) {
                Long accountId = rs_account_count.getLong(1);
                Long accountCount = rs_account_count.getLong(2);

                PreparedStatement account_pstmt = conn.prepareStatement("SELECT domain_id from account where id=?");
                account_pstmt.setLong(1, accountId);
                ResultSet rs_domain = account_pstmt.executeQuery();

                if (!rs_domain.next()) {
                    throw new CloudRuntimeException("Unable to get the domain for the account Id: " + accountId);
                }
                Long domainId = rs_domain.getLong(1);

                rs_domain.close();
                account_pstmt.close();

                // resource count on a domain is aggregate of resource count of all the accounts that belong to the domain and
                // its sub-domains.
                // so propagate the count across the domain hierarchy all the way up to the root domain.
                while (domainId != 0) {

                    PreparedStatement domain_count_pstmt = conn.prepareStatement("SELECT count from resource_count where type='" + resourceType + "' and domain_id=?");
                    domain_count_pstmt.setLong(1, domainId);
                    ResultSet rs_domain_count = domain_count_pstmt.executeQuery();

                    // if a row has been created for the domain in the resource_count table, add the count to the existing
                    // domain count
                    if (rs_domain_count.next()) {
                        Long domainCount = rs_domain_count.getLong(1);
                        domainCount = domainCount + accountCount;
                        PreparedStatement update_domain_count_pstmt =
                            conn.prepareStatement("UPDATE resource_count set count=? where domain_id=? and type ='" + resourceType + "'");
                        update_domain_count_pstmt.setLong(1, domainCount);
                        update_domain_count_pstmt.setLong(2, domainId);
                        update_domain_count_pstmt.executeUpdate();
                        update_domain_count_pstmt.close();
                    } else {
                        PreparedStatement update_domain_count_pstmt = conn.prepareStatement("INSERT INTO resource_count (type, count, domain_id) VALUES (?,?,?)");
                        update_domain_count_pstmt.setString(1, resourceType.getName());
                        update_domain_count_pstmt.setLong(2, accountCount);
                        update_domain_count_pstmt.setLong(3, domainId);
                        update_domain_count_pstmt.executeUpdate();
                        update_domain_count_pstmt.close();
                    }

                    rs_domain_count.close();
                    domain_count_pstmt.close();

                    PreparedStatement parentDomain_pstmt = conn.prepareStatement("SELECT parent from domain where id=?");
                    parentDomain_pstmt.setLong(1, domainId);
                    ResultSet rs_domain_parent = parentDomain_pstmt.executeQuery();

                    if (rs_domain_parent.next()) {
                        domainId = rs_domain_parent.getLong(1);
                    } else {
                        throw new CloudRuntimeException("Unable to get the parent domain for the domain Id: " + domainId);
                    }

                    rs_domain_parent.close();
                    parentDomain_pstmt.close();
                }
            }

            rs_account_count.close();
            account_count_pstmt.close();

        } catch (SQLException e) {
            throw new CloudRuntimeException("Can't upgrade domain resource counts ", e);
        }
    }

    private void upgradeHostCpuCapacityInfo(Connection conn) {
        try {
            // count user_vm memory info (M Bytes)
            PreparedStatement pstmt =
                conn.prepareStatement("select h.id, sum(s.speed*s.cpu) from host h, vm_instance v, service_offering s where h.type='Routing' and v.state='Running' and v.`type`='User' and v.host_id=h.id  and v.service_offering_id = s.id group by h.id");

            ResultSet rs = pstmt.executeQuery();
            Map<Long, Long> hostUsedCpuInfo = new HashMap<Long, Long>();
            while (rs.next()) {
                hostUsedCpuInfo.put(rs.getLong(1), rs.getLong(2));
            }
            rs.close();
            pstmt.close();

            int proxyCpuMhz = NumbersUtil.parseInt(getConfigValue(conn, "consoleproxy.cpu.mhz"), 500); // ConsoleProxyManager.DEFAULT_PROXY_VM_CPUMHZ);
            int domrCpuMhz = NumbersUtil.parseInt(getConfigValue(conn, "router.cpu.mhz"), 500); // VpcVirtualNetworkApplianceManager.DEFAULT_ROUTER_CPU_MHZ);
            int ssvmCpuMhz = NumbersUtil.parseInt(getConfigValue(conn, "secstorage.vm.cpu.mhz"), 500); // SecondaryStorageVmManager.DEFAULT_SS_VM_CPUMHZ);

            pstmt =
                conn.prepareStatement("select h.id, count(v.id) from host h, vm_instance v where h.type='Routing' and v.state='Running' and v.`type`='ConsoleProxy' and v.host_id=h.id group by h.id");

            rs = pstmt.executeQuery();
            while (rs.next()) {
                if (hostUsedCpuInfo.get(rs.getLong(1)) != null) {
                    Long usedCpuMhz = hostUsedCpuInfo.get(rs.getLong(1));
                    hostUsedCpuInfo.put(rs.getLong(1), rs.getLong(2) * proxyCpuMhz + usedCpuMhz);
                } else {
                    hostUsedCpuInfo.put(rs.getLong(1), rs.getLong(2) * proxyCpuMhz);
                }
            }
            rs.close();
            pstmt.close();

            pstmt =
                conn.prepareStatement("select h.id, count(v.id) from host h, vm_instance v where h.type='Routing' and v.state='Running' and v.`type`='DomainRouter' and v.host_id=h.id group by h.id");
            rs = pstmt.executeQuery();
            while (rs.next()) {
                if (hostUsedCpuInfo.get(rs.getLong(1)) != null) {
                    Long usedCpuMhz = hostUsedCpuInfo.get(rs.getLong(1));
                    hostUsedCpuInfo.put(rs.getLong(1), rs.getLong(2) * domrCpuMhz + usedCpuMhz);
                } else {
                    hostUsedCpuInfo.put(rs.getLong(1), rs.getLong(2) * domrCpuMhz);
                }
            }
            rs.close();
            pstmt.close();

            pstmt =
                conn.prepareStatement("select h.id, count(v.id) from host h, vm_instance v where h.type='Routing' and v.state='Running' and v.`type`='SecondaryStorageVm' and v.host_id=h.id group by h.id");
            rs = pstmt.executeQuery();
            while (rs.next()) {
                if (hostUsedCpuInfo.get(rs.getLong(1)) != null) {
                    Long usedCpuMhz = hostUsedCpuInfo.get(rs.getLong(1));
                    hostUsedCpuInfo.put(rs.getLong(1), rs.getLong(2) * ssvmCpuMhz + usedCpuMhz);
                } else {
                    hostUsedCpuInfo.put(rs.getLong(1), rs.getLong(2) * ssvmCpuMhz);
                }
            }
            rs.close();
            pstmt.close();

            for (Map.Entry<Long, Long> entry : hostUsedCpuInfo.entrySet()) {
                pstmt = conn.prepareStatement("update op_host_capacity set used_capacity=? where host_id=? and capacity_type=1");
                pstmt.setLong(1, entry.getValue());
                pstmt.setLong(2, entry.getKey());

                pstmt.executeUpdate();
            }
        } catch (SQLException e) {
            throw new CloudRuntimeException("Can't upgrade host capacity info ", e);
        }
    }

    private String getConfigValue(Connection conn, String name) {
        try {
            // count user_vm memory info (M Bytes)
            PreparedStatement pstmt = conn.prepareStatement("select value from configuration where name=?");
            pstmt.setString(1, name);
            ResultSet rs = pstmt.executeQuery();

            String val = null;
            if (rs.next()) {
                val = rs.getString(1);
            }
            rs.close();
            pstmt.close();

            return val;
        } catch (SQLException e) {
            throw new CloudRuntimeException("Can't upgrade host capacity info ", e);
        }
    }

    private void migrateEvents(Connection conn) {
        try {
            PreparedStatement pstmt1 = conn.prepareStatement("SHOW DATABASES LIKE 'cloud_usage'");
            ResultSet rs1 = pstmt1.executeQuery();
            if (!rs1.next()) {
                s_logger.debug("cloud_usage db doesn't exist. Skipping events migration");
                return;
            }

            // get last processed event Id
            Long lastProcessedEvent = getMostRecentEvent(conn);
            // Events not yet processed
            String sql =
                "SELECT type, description, user_id, account_id, created, level, parameters FROM cloud.event vmevt WHERE vmevt.id > ? and vmevt.state = 'Completed' ";
            if (lastProcessedEvent == null) {
                s_logger.trace("no events are processed earlier, copying all events");
                sql = "SELECT type, description, user_id, account_id, created, level, parameters FROM cloud.event vmevt WHERE vmevt.state = 'Completed' ";
            }

            PreparedStatement pstmt = null;

            pstmt = conn.prepareStatement(sql);
            int i = 1;
            if (lastProcessedEvent != null) {
                pstmt.setLong(i++, lastProcessedEvent);
            }
            ResultSet rs = pstmt.executeQuery();
            s_logger.debug("Begin Migrating events");
            while (rs.next()) {
                EventVO event = new EventVO();
                event.setType(rs.getString(1));
                event.setDescription(rs.getString(2));
                event.setUserId(rs.getLong(3));
                event.setAccountId(rs.getLong(4));
                event.setCreatedDate(DateUtil.parseDateString(TimeZone.getTimeZone("GMT"), rs.getString(5)));
                event.setLevel(rs.getString(6));
                event.setParameters(rs.getString(7));
                convertEvent(event, conn);
            }
            s_logger.debug("Migrating events completed");
        } catch (Exception e) {
            throw new CloudRuntimeException("Failed to migrate usage events: ", e);
        }
    }

    private Long getMostRecentEvent(Connection conn) {
        PreparedStatement pstmt = null;
        String sql = "SELECT id FROM cloud_usage.event ORDER BY created DESC LIMIT 1";
        try {
            pstmt = conn.prepareStatement(sql);
            ResultSet rs = pstmt.executeQuery();
            if (rs.next()) {
                return rs.getLong(1);
            }
        } catch (Exception ex) {
            throw new CloudRuntimeException("error getting most recent event date: " + ex.getMessage());
        }
        return null;
    }

    private void convertEvent(EventVO event, Connection conn) throws IOException, SQLException {
        // we only create usage for success cases as error cases mean
        // the event didn't happen, so it couldn't result in usage
        if (!EventVO.LEVEL_INFO.equals(event.getLevel())) {
            return;
        }
        String eventType = event.getType();
        UsageEventVO usageEvent = null;
        if (isVMEvent(eventType)) {
            usageEvent = convertVMEvent(event);
        } else if (isIPEvent(eventType)) {
            usageEvent = convertIPEvent(event, conn);
        } else if (isVolumeEvent(eventType)) {
            usageEvent = convertVolumeEvent(event, conn);
        } else if (isTemplateEvent(eventType)) {
            usageEvent = convertTemplateEvent(event);
        } else if (isISOEvent(eventType)) {
            usageEvent = convertISOEvent(event);
        } else if (isSnapshotEvent(eventType)) {
            usageEvent = convertSnapshotEvent(event, conn);
        } /*
           * else if (isSecurityGrpEvent(eventType)) { usageEvent = convertSecurityGrpEvent(event); } else if
           * (isLoadBalancerEvent(eventType)) { usageEvent = convertLoadBalancerEvent(event); }
           */
        if (usageEvent != null) {
            usageEvent.setCreatedDate(event.getCreateDate());
            if (usageEvent.getZoneId() == -1) {
                usageEvent.setZoneId(0);
            }
            // update firewall_rules table
            PreparedStatement pstmt = null;
            pstmt =
                conn.prepareStatement("INSERT INTO usage_event (usage_event.type, usage_event.created, usage_event.account_id, usage_event.zone_id, usage_event.resource_id, usage_event.resource_name,"
                    + " usage_event.offering_id, usage_event.template_id, usage_event.size) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
            pstmt.setString(1, usageEvent.getType());
            pstmt.setString(2, DateUtil.getDateDisplayString(TimeZone.getTimeZone("GMT"), usageEvent.getCreateDate()));
            pstmt.setLong(3, usageEvent.getAccountId());
            pstmt.setLong(4, usageEvent.getZoneId());
            pstmt.setLong(5, usageEvent.getResourceId());
            pstmt.setString(6, usageEvent.getResourceName());
            if (usageEvent.getOfferingId() != null) {
                pstmt.setLong(7, usageEvent.getOfferingId());
            } else {
                pstmt.setNull(7, Types.BIGINT);
            }
            if (usageEvent.getTemplateId() != null) {
                pstmt.setLong(8, usageEvent.getTemplateId());
            } else {
                pstmt.setNull(8, Types.BIGINT);
            }
            if (usageEvent.getSize() != null) {
                pstmt.setLong(9, usageEvent.getSize());
            } else {
                pstmt.setNull(9, Types.BIGINT);
            }
            // pstmt.setString(10, usageEvent.getResourceType());
            pstmt.executeUpdate();
            pstmt.close();
        }
    }

    private boolean isVMEvent(String eventType) {
        if (eventType == null) {
            return false;
        }
        return eventType.startsWith("VM.");
    }

    private boolean isIPEvent(String eventType) {
        if (eventType == null) {
            return false;
        }
        return eventType.startsWith("NET.IP");
    }

    private boolean isVolumeEvent(String eventType) {
        if (eventType == null) {
            return false;
        }
        return (eventType.equals(EventTypes.EVENT_VOLUME_CREATE) || eventType.equals(EventTypes.EVENT_VOLUME_DELETE));
    }

    private boolean isTemplateEvent(String eventType) {
        if (eventType == null) {
            return false;
        }
        return (eventType.equals(EventTypes.EVENT_TEMPLATE_CREATE) || eventType.equals(EventTypes.EVENT_TEMPLATE_COPY) || eventType.equals(EventTypes.EVENT_TEMPLATE_DELETE));
    }

    private boolean isISOEvent(String eventType) {
        if (eventType == null) {
            return false;
        }
        return (eventType.equals(EventTypes.EVENT_ISO_CREATE) || eventType.equals(EventTypes.EVENT_ISO_COPY) || eventType.equals(EventTypes.EVENT_ISO_DELETE));
    }

    private boolean isSnapshotEvent(String eventType) {
        if (eventType == null) {
            return false;
        }
        return (eventType.equals(EventTypes.EVENT_SNAPSHOT_CREATE) || eventType.equals(EventTypes.EVENT_SNAPSHOT_DELETE));
    }

    private boolean isLoadBalancerEvent(String eventType) {
        if (eventType == null) {
            return false;
        }
        return eventType.startsWith("LB.");
    }

    private UsageEventVO convertVMEvent(EventVO event) throws IOException {

        Properties vmEventParams = new Properties();
        UsageEventVO usageEvent = null;
        long vmId = -1L;
        long soId = -1L; // service offering id
        long zoneId = -1L;
        String eventParams = event.getParameters();
        if (eventParams != null) {
            vmEventParams.load(new StringReader(eventParams));
            vmId = Long.parseLong(vmEventParams.getProperty("id"));
            soId = Long.parseLong(vmEventParams.getProperty("soId"));
            zoneId = Long.parseLong(vmEventParams.getProperty("dcId"));
        }

        if (EventTypes.EVENT_VM_START.equals(event.getType())) {
            long templateId = 0;
            String tId = vmEventParams.getProperty("tId");
            if (tId != null) {
                templateId = Long.parseLong(tId);
            }

            usageEvent = new UsageEventVO(EventTypes.EVENT_VM_START, event.getAccountId(), zoneId, vmId, vmEventParams.getProperty("vmName"), soId, templateId, "");
        } else if (EventTypes.EVENT_VM_STOP.equals(event.getType())) {
            usageEvent = new UsageEventVO(EventTypes.EVENT_VM_STOP, event.getAccountId(), zoneId, vmId, vmEventParams.getProperty("vmName"));
        } else if (EventTypes.EVENT_VM_CREATE.equals(event.getType())) {
            Long templateId = null;
            String tId = vmEventParams.getProperty("tId");
            if (tId != null) {
                templateId = new Long(Long.parseLong(tId));
            }

            usageEvent = new UsageEventVO(EventTypes.EVENT_VM_CREATE, event.getAccountId(), zoneId, vmId, vmEventParams.getProperty("vmName"), soId, templateId, "");
        } else if (EventTypes.EVENT_VM_DESTROY.equals(event.getType())) {
            usageEvent = new UsageEventVO(EventTypes.EVENT_VM_DESTROY, event.getAccountId(), zoneId, vmId, vmEventParams.getProperty("vmName"));
        }
        return usageEvent;
    }

    private UsageEventVO convertIPEvent(EventVO event, Connection conn) throws IOException, SQLException {

        Properties ipEventParams = new Properties();
        UsageEventVO usageEvent = null;
        ipEventParams.load(new StringReader(event.getParameters()));
        String ipAddress = ipEventParams.getProperty("address");
        if (ipAddress == null) {
            ipAddress = ipEventParams.getProperty("guestIPaddress");
            if (ipAddress == null) {
                // can not find IP address, bail for this event
                return null;
            }
        }

        // Get ip address information
        Long ipId = 0L;
        Long zoneId = 0L;
        PreparedStatement pstmt = conn.prepareStatement("SELECT id, data_center_id from user_ip_address where public_ip_address=?");
        pstmt.setString(1, ipAddress);
        ResultSet rs = pstmt.executeQuery();
        if (rs.next()) {
            ipId = rs.getLong(1);
            zoneId = rs.getLong(2);
        }
        rs.close();
        pstmt.close();

        boolean isSourceNat = Boolean.parseBoolean(ipEventParams.getProperty("sourceNat"));

        if (EventTypes.EVENT_NET_IP_ASSIGN.equals(event.getType())) {
            zoneId = Long.parseLong(ipEventParams.getProperty("dcId"));
            usageEvent = new UsageEventVO(EventTypes.EVENT_NET_IP_ASSIGN, event.getAccountId(), zoneId, ipId, ipAddress, isSourceNat, "", false);
        } else if (EventTypes.EVENT_NET_IP_RELEASE.equals(event.getType())) {
            usageEvent = new UsageEventVO(EventTypes.EVENT_NET_IP_RELEASE, event.getAccountId(), zoneId, ipId, ipAddress, isSourceNat, "", false);
        }
        return usageEvent;
    }

    private UsageEventVO convertVolumeEvent(EventVO event, Connection conn) throws IOException, SQLException {

        Properties volEventParams = new Properties();
        long volId = -1L;
        Long doId = -1L;
        long zoneId = -1L;
        Long templateId = -1L;
        long size = -1L;
        UsageEventVO usageEvent = null;
        volEventParams.load(new StringReader(event.getParameters()));
        volId = Long.parseLong(volEventParams.getProperty("id"));
        if (EventTypes.EVENT_VOLUME_CREATE.equals(event.getType())) {
            doId = Long.parseLong(volEventParams.getProperty("doId"));
            zoneId = Long.parseLong(volEventParams.getProperty("dcId"));
            templateId = Long.parseLong(volEventParams.getProperty("tId"));
            size = Long.parseLong(volEventParams.getProperty("size"));
            size = (size * 1048576);
            if (doId == -1) {
                doId = null;
            }
            if (templateId == -1) {
                templateId = null;
            }
        }

        // Get volume name information
        String volumeName = "";
        PreparedStatement pstmt = conn.prepareStatement("SELECT name, data_center_id from volumes where id=?");
        pstmt.setLong(1, volId);
        ResultSet rs = pstmt.executeQuery();
        if (rs.next()) {
            volumeName = rs.getString(1);
            zoneId = rs.getLong(2);
        }
        rs.close();
        pstmt.close();

        if (EventTypes.EVENT_VOLUME_CREATE.equals(event.getType())) {
            usageEvent = new UsageEventVO(EventTypes.EVENT_VOLUME_CREATE, event.getAccountId(), zoneId, volId, volumeName, doId, templateId, size);
        } else if (EventTypes.EVENT_VOLUME_DELETE.equals(event.getType())) {
            usageEvent = new UsageEventVO(EventTypes.EVENT_VOLUME_DELETE, event.getAccountId(), zoneId, volId, volumeName);

        }
        return usageEvent;
    }

    private UsageEventVO convertTemplateEvent(EventVO event) throws IOException {

        Properties templateEventParams = new Properties();
        long templateId = -1L;
        long zoneId = -1L;
        long templateSize = -1L;
        UsageEventVO usageEvent = null;

        templateEventParams.load(new StringReader(event.getParameters()));
        templateId = Long.parseLong(templateEventParams.getProperty("id"));
        if (templateEventParams.getProperty("dcId") != null) {
            zoneId = Long.parseLong(templateEventParams.getProperty("dcId"));
        }
        if (EventTypes.EVENT_TEMPLATE_CREATE.equals(event.getType()) || EventTypes.EVENT_TEMPLATE_COPY.equals(event.getType())) {
            templateSize = Long.parseLong(templateEventParams.getProperty("size"));
            if (templateSize < 1) {
                return null;
            }
            if (zoneId == -1L) {
                return null;
            }
            usageEvent = new UsageEventVO(event.getType(), event.getAccountId(), zoneId, templateId, "", null, null, templateSize);
        } else if (EventTypes.EVENT_TEMPLATE_DELETE.equals(event.getType())) {
            usageEvent = new UsageEventVO(event.getType(), event.getAccountId(), zoneId, templateId, null);
        }
        return usageEvent;
    }

    private UsageEventVO convertISOEvent(EventVO event) throws IOException {
        Properties isoEventParams = new Properties();
        long isoId = -1L;
        long isoSize = -1L;
        long zoneId = -1L;
        UsageEventVO usageEvent = null;

        isoEventParams.load(new StringReader(event.getParameters()));
        isoId = Long.parseLong(isoEventParams.getProperty("id"));
        if (isoEventParams.getProperty("dcId") != null) {
            zoneId = Long.parseLong(isoEventParams.getProperty("dcId"));
        }

        if (EventTypes.EVENT_ISO_CREATE.equals(event.getType()) || EventTypes.EVENT_ISO_COPY.equals(event.getType())) {
            isoSize = Long.parseLong(isoEventParams.getProperty("size"));
            usageEvent = new UsageEventVO(event.getType(), event.getAccountId(), zoneId, isoId, "", null, null, isoSize);
        } else if (EventTypes.EVENT_ISO_DELETE.equals(event.getType())) {
            usageEvent = new UsageEventVO(event.getType(), event.getAccountId(), zoneId, isoId, null);
        }
        return usageEvent;
    }

    private UsageEventVO convertSnapshotEvent(EventVO event, Connection conn) throws IOException, SQLException {
        Properties snapEventParams = new Properties();
        long snapId = -1L;
        long snapSize = -1L;
        Long zoneId = 0L;
        UsageEventVO usageEvent = null;

        snapEventParams.load(new StringReader(event.getParameters()));
        snapId = Long.parseLong(snapEventParams.getProperty("id"));
        String snapshotName = snapEventParams.getProperty("ssName");

        String size = snapEventParams.getProperty("size");
        if (size != null) {
            snapSize = Long.parseLong(size);
        }

        String zoneString = snapEventParams.getProperty("dcId");
        if (zoneString != null) {
            zoneId = Long.parseLong(zoneString);
        }

        Long accountId = event.getAccountId();

        // Get snapshot info (there was a bug in 2.1.x - accountId is 0, and data_center info is not present in events table
        if (accountId.longValue() == 0L || zoneId.longValue() == 0L) {
            PreparedStatement pstmt = conn.prepareStatement("SELECT zone_id, account_id from usage_event where resource_id=? and type like '%SNAPSHOT%'");
            pstmt.setLong(1, snapId);
            ResultSet rs = pstmt.executeQuery();
            if (rs.next()) {
                zoneId = rs.getLong(1);
                accountId = rs.getLong(2);
            }

            rs.close();
            pstmt.close();
        }

        if (EventTypes.EVENT_SNAPSHOT_CREATE.equals(event.getType())) {
            usageEvent = new UsageEventVO(EventTypes.EVENT_SNAPSHOT_CREATE, accountId, zoneId, snapId, snapshotName, null, null, snapSize);
        } else if (EventTypes.EVENT_SNAPSHOT_DELETE.equals(event.getType())) {
            usageEvent = new UsageEventVO(EventTypes.EVENT_SNAPSHOT_DELETE, accountId, zoneId, snapId, snapshotName, null, null, 0L);
        }
        return usageEvent;
    }

    @Override
    public void performDataMigration(Connection conn) {
        try {
            PreparedStatement pstmt = conn.prepareStatement("USE cloud");
            pstmt.executeQuery();
            upgradeDataCenter(conn);
            upgradeStoragePools(conn);
            upgradeInstanceGroups(conn);
            upgradePortForwardingRules(conn);
            upgradeLoadBalancingRules(conn);
            upgradeHostMemoryCapacityInfo(conn);
            upgradeHostCpuCapacityInfo(conn);
            upgradeDomainResourceCounts(conn);

            migrateEvents(conn);
            createPortForwardingEvents(conn);
            createLoadBalancerEvents(conn);
            createNetworkOfferingEvents(conn);

            // Update hypervisor type for user vm to be consistent with original 2.2.4
            pstmt = conn.prepareStatement("UPDATE vm_instance SET hypervisor_type='XenServer' WHERE hypervisor_type='xenserver'");
            pstmt.executeUpdate();
            pstmt.close();

            // Set account=systemAccount and domain=ROOT for CPVM/SSVM
            pstmt = conn.prepareStatement("UPDATE vm_instance SET account_id=1, domain_id=1 WHERE type='ConsoleProxy' or type='SecondaryStorageVm'");
            pstmt.executeUpdate();
            pstmt.close();

            // Update user statistics
            updateUserStats(conn);

            // delete orphaned (storage pool no longer exists) template_spool_ref(s)
            deleteOrphanedTemplateRef(conn);

            // Upgrade volumes with incorrect Destroyed field
            cleanupVolumes(conn);

            // modify network_group indexes
            modifyIndexes(conn);

            // cleanup lb - vm maps for load balancers that are already removed (there was a bug in 2.1.x when the mappings were
            // left around)
            cleanupLbVmMaps(conn);

        } catch (SQLException e) {
            s_logger.error("Can't perform data migration ", e);
            throw new CloudRuntimeException("Can't perform data migration ", e);
        }

    }

    @Override
    public File[] getCleanupScripts() {
        String file = Script.findScript("", "db/schema-21to22-cleanup.sql");
        if (file == null) {
            throw new CloudRuntimeException("Unable to find the upgrade script, schema-21to22-cleanup.sql");
        }

        return new File[] {new File(file)};
    }

    @Override
    public String[] getUpgradableVersionRange() {
        return new String[] {"2.1.8", "2.1.8"};
    }

    @Override
    public String getUpgradedVersion() {
        return "2.2.1";
    }

    @Override
    public boolean supportsRollingUpgrade() {
        return false;
    }

    private void deleteOrphanedTemplateRef(Connection conn) {
        try {
            PreparedStatement pstmt = conn.prepareStatement("SELECT id, pool_id from template_spool_ref");
            ResultSet rs = pstmt.executeQuery();
            if (!rs.next()) {
                s_logger.debug("No records in template_spool_ref, skipping this upgrade part");
                return;
            }

            while (rs.next()) {
                Long id = rs.getLong(1);
                Long poolId = rs.getLong(2);

                pstmt = conn.prepareStatement("SELECT * from storage_pool where id=?");
                pstmt.setLong(1, poolId);
                ResultSet rs1 = pstmt.executeQuery();

                if (!rs1.next()) {
                    s_logger.debug("Orphaned template_spool_ref record is found (storage pool doesn't exist any more0) id=" + id + "; so removing the record");
                    pstmt = conn.prepareStatement("DELETE FROM template_spool_ref where id=?");
                    pstmt.setLong(1, id);
                    pstmt.executeUpdate();
                }

            }
            rs.close();
            pstmt.close();

            s_logger.debug("Finished deleting orphaned template_spool_ref(s)");
        } catch (Exception e) {
            s_logger.error("Failed to delete orphaned template_spool_ref(s): ", e);
            throw new CloudRuntimeException("Failed to delete orphaned template_spool_ref(s): ", e);
        }
    }

    private void cleanupVolumes(Connection conn) {
        try {
            PreparedStatement pstmt = conn.prepareStatement("SELECT id, instance_id, account_id from volumes where destroyed=127");
            ResultSet rs = pstmt.executeQuery();

            while (rs.next()) {
                Long id = rs.getLong(1);
                s_logger.debug("Volume id is " + id);
                Long instanceId = rs.getLong(2);
                Long accountId = rs.getLong(3);

                boolean removeVolume = false;

                pstmt = conn.prepareStatement("SELECT * from account where id=? and removed is not null");
                pstmt.setLong(1, accountId);
                ResultSet rs1 = pstmt.executeQuery();

                if (rs1.next()) {
                    removeVolume = true;
                }

                if (instanceId != null) {
                    pstmt = conn.prepareStatement("SELECT * from vm_instance where id=? and removed is not null");
                    pstmt.setLong(1, instanceId);
                    rs1 = pstmt.executeQuery();

                    if (rs1.next()) {
                        removeVolume = true;
                    }
                }

                if (removeVolume) {
                    pstmt = conn.prepareStatement("UPDATE volumes SET state='Destroy' WHERE id=?");
                    pstmt.setLong(1, id);
                    pstmt.executeUpdate();
                    s_logger.debug("Volume with id=" + id + " is marked with Destroy state as a part of volume cleanup (it's Destroyed had 127 value)");
                }
            }
            rs.close();
            pstmt.close();

            s_logger.debug("Finished cleaning up volumes with incorrect Destroyed field (127)");
        } catch (Exception e) {
            s_logger.error("Failed to cleanup volumes with incorrect Destroyed field (127):", e);
            throw new CloudRuntimeException("Failed to cleanup volumes with incorrect Destroyed field (127):", e);
        }
    }

    private void modifyIndexes(Connection conn) {
        try {

            // removed indexes
            PreparedStatement pstmt = conn.prepareStatement("SHOW INDEX FROM security_group WHERE KEY_NAME = 'fk_network_group__account_id'");
            ResultSet rs = pstmt.executeQuery();

            if (rs.next()) {
                pstmt = conn.prepareStatement("ALTER TABLE `cloud`.`security_group` DROP INDEX `fk_network_group__account_id`");
                pstmt.executeUpdate();
                s_logger.debug("Unique key 'fk_network_group__account_id' is removed successfully");
            }

            rs.close();
            pstmt.close();

            pstmt = conn.prepareStatement("SHOW INDEX FROM security_group WHERE KEY_NAME = 'fk_network_group___account_id'");
            rs = pstmt.executeQuery();

            if (rs.next()) {
                pstmt = conn.prepareStatement("ALTER TABLE `cloud`.`security_group` DROP INDEX `fk_network_group___account_id`");
                pstmt.executeUpdate();
                s_logger.debug("Unique key 'fk_network_group___account_id' is removed successfully");
            }

            rs.close();
            pstmt.close();

            // add indexes
            pstmt =
                conn.prepareStatement("ALTER TABLE `cloud`.`security_group` ADD CONSTRAINT `fk_security_group___account_id` FOREIGN KEY `fk_security_group__account_id` (`account_id`) REFERENCES `account` (`id`) ON DELETE CASCADE");
            pstmt.executeUpdate();
            pstmt.close();

        } catch (SQLException e) {
            throw new CloudRuntimeException("Unable to drop indexes for 'security_group' table due to:", e);
        }
    }

    // There was a bug in 2.1.x when LB rule mapping wasn't removed along with lb rule removal
    // Do cleanup after making sure that the rule was removed
    private void cleanupLbVmMaps(Connection conn) {
        try {
            PreparedStatement pstmt = conn.prepareStatement("SELECT DISTINCT load_balancer_id FROM load_balancer_vm_map");
            ResultSet rs = pstmt.executeQuery();

            while (rs.next()) {
                long lbId = rs.getLong(1);
                PreparedStatement pstmt1 = conn.prepareStatement("SELECT * FROM load_balancer where id=?");
                pstmt1.setLong(1, lbId);
                ResultSet rs1 = pstmt1.executeQuery();

                PreparedStatement pstmt2 = conn.prepareStatement("SELECT * from event where type like '%lb.delete%' and parameters like '%id=" + lbId + "%'");
                ResultSet rs2 = pstmt2.executeQuery();

                if (!rs1.next() && rs2.next()) {
                    s_logger.debug("Removing load balancer vm mappings for lb id=" + lbId + " as a part of cleanup");
                    pstmt = conn.prepareStatement("DELETE FROM load_balancer_vm_map where load_balancer_id=?");
                    pstmt.setLong(1, lbId);
                    pstmt.executeUpdate();
                }
                rs1.close();
                rs2.close();
                pstmt1.close();
                pstmt2.close();
            }

            rs.close();
            pstmt.close();

        } catch (SQLException e) {
            throw new CloudRuntimeException("Failed to cleanup orpahned lb-vm mappings due to:", e);
        }
    }

    /*
     * Create usage events for existing port forwarding rules
     */
    private void createPortForwardingEvents(Connection conn) {
        try {
            PreparedStatement pstmt =
                conn.prepareStatement("SELECT fw.account_id, ip.data_center_id, fw.id FROM firewall_rules fw, user_ip_address ip where purpose = 'PortForwarding' and "
                    + "fw.state = 'Active' and ip.id = fw.ip_address_id");
            s_logger.debug("Creating Port Forwarding usage events");
            ResultSet rs = pstmt.executeQuery();
            Date now = new Date();
            while (rs.next()) {
                long accountId = rs.getLong(1);
                long zoneId = rs.getLong(2);
                long ruleId = rs.getLong(3);
                PreparedStatement pstmt1 = null;
                pstmt1 =
                    conn.prepareStatement("INSERT INTO usage_event (usage_event.type, usage_event.created, usage_event.account_id, usage_event.zone_id, usage_event.resource_id)"
                        + " VALUES (?, ?, ?, ?, ?)");
                pstmt1.setString(1, EventTypes.EVENT_NET_RULE_ADD);
                pstmt1.setString(2, DateUtil.getDateDisplayString(TimeZone.getTimeZone("GMT"), now));
                pstmt1.setLong(3, accountId);
                pstmt1.setLong(4, zoneId);
                pstmt1.setLong(5, ruleId);

                pstmt1.executeUpdate();
                pstmt1.close();
            }

            rs.close();
            pstmt.close();
            s_logger.debug("Completed creating Port Forwarding usage events");

        } catch (SQLException e) {
            throw new CloudRuntimeException("Failed to add port forwarding usage events due to:", e);
        }
    }

    /*
     * Create usage events for existing load balancer rules
     */
    private void createLoadBalancerEvents(Connection conn) {
        try {
            PreparedStatement pstmt =
                conn.prepareStatement("SELECT fw.account_id, ip.data_center_id, fw.id FROM firewall_rules fw, user_ip_address ip where purpose = 'LoadBalancing' and "
                    + "fw.state = 'Active' and ip.id = fw.ip_address_id");
            s_logger.debug("Creating load balancer usage events");
            ResultSet rs = pstmt.executeQuery();
            Date now = new Date();
            while (rs.next()) {
                long accountId = rs.getLong(1);
                long zoneId = rs.getLong(2);
                long ruleId = rs.getLong(3);
                PreparedStatement pstmt1 = null;
                pstmt1 =
                    conn.prepareStatement("INSERT INTO usage_event (usage_event.type, usage_event.created, usage_event.account_id, usage_event.zone_id, usage_event.resource_id)"
                        + " VALUES (?, ?, ?, ?, ?)");
                pstmt1.setString(1, EventTypes.EVENT_LOAD_BALANCER_CREATE);
                pstmt1.setString(2, DateUtil.getDateDisplayString(TimeZone.getTimeZone("GMT"), now));
                pstmt1.setLong(3, accountId);
                pstmt1.setLong(4, zoneId);
                pstmt1.setLong(5, ruleId);

                pstmt1.executeUpdate();
                pstmt1.close();
            }

            rs.close();
            pstmt.close();
            s_logger.debug("Completed creating load balancer usage events");

        } catch (SQLException e) {
            throw new CloudRuntimeException("Failed to add Load Balancer usage events due to:", e);
        }
    }

    /*
     * Create usage events for network offerings
     */
    private void createNetworkOfferingEvents(Connection conn) {
        try {
            PreparedStatement pstmt =
                conn.prepareStatement("SELECT vm.account_id, vm.data_center_id, ni.instance_id, vm.name, nw.network_offering_id, nw.is_default FROM nics ni, "
                    + "networks nw, vm_instance vm where vm.type = 'User' and ni.removed is null and ni.instance_id = vm.id and ni.network_id = nw.id;");
            s_logger.debug("Creating network offering usage events");
            ResultSet rs = pstmt.executeQuery();
            Date now = new Date();
            while (rs.next()) {
                long accountId = rs.getLong(1);
                long zoneId = rs.getLong(2);
                long vmId = rs.getLong(3);
                String vmName = rs.getString(4);
                long nw_offering_id = rs.getLong(5);
                long isDefault = rs.getLong(6);
                PreparedStatement pstmt1 = null;
                pstmt1 =
                    conn.prepareStatement("INSERT INTO usage_event (usage_event.type, usage_event.created, usage_event.account_id, usage_event.zone_id, usage_event.resource_id, usage_event.resource_name, "
                        + "usage_event.offering_id, usage_event.size)" + " VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
                pstmt1.setString(1, EventTypes.EVENT_NETWORK_OFFERING_ASSIGN);
                pstmt1.setString(2, DateUtil.getDateDisplayString(TimeZone.getTimeZone("GMT"), now));
                pstmt1.setLong(3, accountId);
                pstmt1.setLong(4, zoneId);
                pstmt1.setLong(5, vmId);
                pstmt1.setString(6, vmName);
                pstmt1.setLong(7, nw_offering_id);
                pstmt1.setLong(8, isDefault);

                pstmt1.executeUpdate();
                pstmt1.close();
            }

            rs.close();
            pstmt.close();
            s_logger.debug("Completed creating network offering usage events");

        } catch (SQLException e) {
            throw new CloudRuntimeException("Failed to add network offering usage events due to:", e);
        }
    }

}
