# 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.

import marvin
from marvin.cloudstackTestCase import *
from marvin.cloudstackAPI import *
from marvin.lib.utils import *
from marvin.lib.base import *
from marvin.lib.common import *
from nose.plugins.attrib import attr

import random

from ipmisim.ipmisim import IpmiServerContext, IpmiServer, ThreadedIpmiServer

import random
import socket
import sys
import _thread
import time


class TestHAKVM(cloudstackTestCase):
    """ Test cases for host HA using KVM host(s)
    """

    def setUp(self):
        self.testClient = super(TestHAKVM, self).getClsTestClient()
        self.apiclient = self.testClient.getApiClient()
        self.dbclient = self.testClient.getDbConnection()
        self.services = self.testClient.getParsedTestDataConfig()
        self.logger = logging.getLogger('TestHAKVM')

        #Get Zone specifics
        self.zone = get_zone(self.apiclient, self.testClient.getZoneForTests())
        self.hypervisor = self.testClient.getHypervisorInfo()
        self.host = self.getHost()
        self.hostConfig = self.config.__dict__["zones"][0].__dict__["pods"][0].__dict__["clusters"][0].__dict__["hosts"][0].__dict__
        self.mgtSvrDetails = self.config.__dict__["mgtSvr"][0].__dict__
        self.cluster_id = self.host.clusterid

        # Cleanup any existing configs
        self.dbclient.execute("delete from ha_config where resource_type='Host'")

        # use random port for ipmisim
        self.fakeMsId = random.randint(10000, 99999) * random.randint(10, 20)
        s = socket.socket()
        s.bind(('', 0))
        self.serverPort = s.getsockname()[1]
        s.close()

        # Set Cluster-level setting in order to run tests faster
        self.updateConfiguration("kvm.ha.activity.check.failure.ratio", "0.6")
        self.updateConfiguration("kvm.ha.activity.check.interval", "8")
        self.updateConfiguration("kvm.ha.activity.check.max.attempts", "5")
        self.updateConfiguration("kvm.ha.activity.check.timeout", "30")
        self.updateConfiguration("kvm.ha.degraded.max.period", "30")
        self.updateConfiguration("kvm.ha.fence.timeout", "30")
        self.updateConfiguration("kvm.ha.health.check.timeout", "30")
        self.updateConfiguration("kvm.ha.recover.failure.threshold", "2")
        self.updateConfiguration("kvm.ha.recover.timeout", "30")
        self.updateConfiguration("kvm.ha.recover.wait.period", "30")

        self.service_offering = ServiceOffering.create(
            self.apiclient,
            self.services["service_offerings"]["hasmall"]
        )

        self.template = get_test_template(
            self.apiclient,
            self.zone.id,
            self.hypervisor
        )

        self.configureAndDisableHostHa()
        self.cleanup = [self.service_offering]

    def updateConfiguration(self, name, value):
        cmd = updateConfiguration.updateConfigurationCmd()
        cmd.name = name
        cmd.value = value
        cmd.clusterid = self.cluster_id
        self.apiclient.updateConfiguration(cmd)

    def getFakeMsId(self):
        return self.fakeMsId

    def getFakeMsRunId(self):
        return self.fakeMsId * 1000

    def tearDown(self):
        self.configureAndDisableHostHa()
        self.host = None
        try:
            self.dbclient.execute("delete from mshost_peer where peer_runid=%s" % self.getFakeMsRunId())
            self.dbclient.execute("delete from mshost where runid=%s" % self.getFakeMsRunId())
            self.dbclient.execute("delete from cluster_details where name='resourceHAEnabled'")
            self.dbclient.execute("delete from data_center_details where name='resourceHAEnabled'")
            self.dbclient.execute("delete from ha_config where resource_type='Host'")
            self.dbclient.execute("delete from oobm where port=%d" % self.getIpmiServerPort())
            self.dbclient.execute("delete from mshost_peer where peer_runid=%s" % self.getFakeMsRunId())
            self.dbclient.execute("delete from mshost where runid=%s" % self.getFakeMsRunId())
            self.dbclient.execute("delete from cluster_details where name='outOfBandManagementEnabled'")
            self.dbclient.execute("delete from data_center_details where name='outOfBandManagementEnabled'")
            cleanup_resources(self.apiclient, self.cleanup)
        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)

    def getHostHaEnableCmd(self):
        cmd = enableHAForHost.enableHAForHostCmd()
        cmd.hostid = self.host.id
        return cmd

    def getHost(self, hostId=None):
        response = list_hosts(
            self.apiclient,
            type='Routing',
            hypervisor='kvm',
            id=hostId
        )
        # Check if more than one kvm hosts are available in order to successfully configure host-ha
        if response and len(response) > 0:
            self.host = response[0]
            return self.host
        raise self.skipTest("Not enough KVM hosts found, skipping host-ha test")

    def getHostHaConfigCmd(self, provider='kvmhaprovider'):
        cmd = configureHAForHost.configureHAForHostCmd()
        cmd.provider = provider
        cmd.hostid = self.host.id
        return cmd

    def getHostHaDisableCmd(self):
        cmd = disableHAForHost.disableHAForHostCmd()
        cmd.hostid = self.host.id
        return cmd

    def configureAndEnableHostHa(self):
        #Adding sleep between configuring and enabling
        self.apiclient.configureHAForHost(self.getHostHaConfigCmd())
        response = self.apiclient.enableHAForHost(self.getHostHaEnableCmd())
        self.assertEqual(response.haenable, True)

    def configureAndDisableHostHa(self):
        self.apiclient.configureHAForHost(self.getHostHaConfigCmd())
        cmd = self.getHostHaDisableCmd()
        cmd.hostid = self.host.id
        response = self.apiclient.disableHAForHost(cmd)
        self.assertEqual(response.hostid, cmd.hostid)
        self.assertEqual(response.haenable, False)

    def enableHostHa(self, hostId):
        cmd = self.getHostHaEnableCmd()
        cmd.hostid = hostId
        response = self.apiclient.enableHAForHost(cmd)
        self.assertEqual(response.hostid, cmd.hostid)
        self.assertEqual(response.haenable, True)
        return response

    def disableAgent(self):
        SshClient(self.host.ipaddress, port=22, user=self.hostConfig["username"], passwd=self.hostConfig["password"]).execute\
            ("systemctl disable cloudstack-agent || chkconfig cloudstack-agent off")

    def resetHost(self):
        SshClient(self.host.ipaddress, port=22, user=self.hostConfig["username"],
                  passwd=self.hostConfig["password"]).execute \
            ("reboot")

    def enableAgent(self):
        SshClient(self.host.ipaddress, port=22, user=self.hostConfig["username"], passwd=self.hostConfig["password"]).execute\
            ("systemctl enable cloudstack-agent || chkconfig cloudstack-agent on")

    def waitUntilHostInState(self, state="Available", interval=3):
        def checkForState(expectedState):
            response = self.getHost(self.host.id)
            print("checkForState:: expected=%s, actual=%s" % (state, response.hostha))
            return response.hostha.hastate == expectedState, None

        res, _ = wait_until(interval, 200, checkForState, state)
        if not res:
            self.fail("Failed to see host ha state in :" + state)

    def deployVM(self):
        try:
            vm = VirtualMachine.create(
                self.apiclient,
                services=self.services["virtual_machine"],
                serviceofferingid=self.service_offering.id,
                templateid=self.template.id,
                zoneid=self.zone.id,
                hostid = self.host.id,
                method="POST"
            )
            self.cleanup.append(vm)
        except Exception as e:
            raise self.skipTest("Failed to deploy VM, skipping kvm host-ha test case")

    def skipIfMSIsUnsupported(self) :
        os_details = SshClient(self.mgtSvrDetails["mgtSvrIp"], 22, self.mgtSvrDetails["user"], self.mgtSvrDetails["passwd"]).execute \
            ("/usr/share/cloudstack-common/scripts/vm/hypervisor/versions.sh | cut -d '=' -f2")
        os = os_details[0].lower()
        if 'ubuntu' in os or 'debian' in os :
            return
        # RHEL < 8 works fine
        os_ver = os_details[1].split('.')[0]
        if float(os_ver) < 8:
            return
        self.skipTest("Skipping since RHEL8 / SUSE have known IPMI issues")

    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
    def test_disable_oobm_ha_state_ineligible(self):
        """
            Tests that when HA is enabled for a host, if oobm is disabled HA State should turn into Ineligible
        """
        self.logger.debug("Starting test_disable_oobm_ha_state_ineligible")

        # Enable ha for host
        self.configureAndEnableHostHa()

        # Disable OOBM
        self.apiclient.configureOutOfBandManagement(self.getOobmConfigCmd())
        oobm_cmd = self.getOobmDisableCmd()
        oobm_cmd.hostid = self.host.id
        response = self.apiclient.disableOutOfBandManagementForHost(oobm_cmd)
        self.assertEqual(response.hostid, oobm_cmd.hostid)
        self.assertEqual(response.enabled, False)

        response = self.getHost(hostId=self.host.id).outofbandmanagement
        self.assertEqual(response.powerstate, 'Disabled')

        # Verify HA State is Ineligeble
        self.waitUntilHostInState("Ineligible")

    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
    def test_hostha_configure_default_driver(self):
        """
            Tests host-ha configuration with valid data
        """
        self.logger.debug("Starting test_hostha_configure_default_driver")

        cmd = self.getHostHaConfigCmd()
        response = self.apiclient.configureHAForHost(cmd)
        self.assertEqual(response.hostid, cmd.hostid)
        self.assertEqual(response.haprovider, cmd.provider.lower())

    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
    def test_hostha_enable_ha_when_host_disabled(self):
        """
            Tests Enable HA when host is disconnected, should be Ineligible
        """
        self.logger.debug("Starting test_hostha_enable_ha_when_host_disabled")

        # Enable HA
        self.configureAndEnableHostHa()

        # Disable Host
        self.disableHost(self.host.id)

        # Check HA State
        try:
            self.waitUntilHostInState("Ineligible")
        except Exception as e:
            self.enableHost(self.host.id)
            self.fail(e)

        # Enable Host
        self.enableHost(self.host.id)

    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
    def test_hostha_enable_ha_when_host_in_maintenance(self):
        """
            Tests Enable HA when host is in Maintenance mode, should be Ineligible
        """
        self.logger.debug("Starting test_hostha_enable_ha_when_host_in_maintenance")
        self.logger.debug("Pausing to wait for VMs to have finished starting")
        time.sleep(300)

        # Enable HA
        self.configureAndEnableHostHa()


        # Prepare for maintenance Host
        self.setHostToMaintanance(self.host.id)

        # Check HA State
        try:
            self.waitUntilHostInState("Ineligible")
        except Exception as e:
            self.cancelMaintenance()
            self.fail(e)

        # Enable Host
        self.cancelMaintenance()

    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
    def test_hostha_enable_ha_when_host_disconected(self):
        """
            Tests Enable HA when host is disconnected, should be Ineligible
        """
        self.logger.debug("Starting test_hostha_enable_ha_when_host_disconected")

        # Enable HA
        self.apiclient.configureHAForHost(self.getHostHaConfigCmd())
        cmd = self.getHostHaEnableCmd()
        cmd.hostid = self.host.id
        enable = self.apiclient.enableHAForHost(cmd)
        self.assertEqual(enable.hostid, cmd.hostid)
        self.assertEqual(enable.haenable, True)

        # Make Host Disconnected
        self.killAgent()

        # Check HA State
        try:
            self.waitUntilHostInState("Ineligible")
        except Exception as e:
            self.startAgent()
            self.fail(e)

        # Enable Host
        self.startAgent()

    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
    def test_remove_ha_provider_not_possible(self):
        """
            Tests HA Provider should be possible to be removed when HA is enabled
        """
        self.logger.debug("Starting test_remove_ha_provider_not_possible")


        # Enable HA
        self.apiclient.configureHAForHost(self.getHostHaConfigCmd())
        cmd = self.getHostHaEnableCmd()
        cmd.hostid = self.host.id
        enable = self.apiclient.enableHAForHost(cmd)
        self.assertEqual(enable.hostid, cmd.hostid)
        self.assertEqual(enable.haenable, True)

        try:
            self.apiclient.configureHAForHost(self.getHostHaConfigCmd(''))
        except Exception:
            pass
        else:
            self.fail("Expected an exception to be thrown, failing")

    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
    def test_hostha_kvm_host_degraded(self):
        """
            Tests degraded HA state when agent is stopped/killed
        """

        self.skipIfMSIsUnsupported()
        self.configureAndStartIpmiServer()
        self.assertIssueCommandState('ON', 'On')
        self.configureAndEnableHostHa()

        self.deployVM()

        # Start with the available state
        self.waitUntilHostInState("Available")

        # SSH into the KVM Host and executes kill -9 of the agent
        self.stopAgent()

        # Check if host would go into Suspect state
        try:
            self.waitUntilHostInState("Suspect")
        except Exception as e:
            self.startAgent()
            raise Exception("Warning: Exception during test execution : %s" % e)

        # Checks if the host would turn into Degraded
        try:
            self.waitUntilHostInState("Degraded")
        except Exception as e:
            self.startAgent()
            raise Exception("Warning: Exception during test execution : %s" % e)

        self.startAgent()
        self.waitUntilHostInState("Available")


    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
    def test_hostha_kvm_host_recovering(self):
        """
            Tests recovery and fencing HA state transitions
        """

        self.skipIfMSIsUnsupported()
        self.configureAndStartIpmiServer()
        self.assertIssueCommandState('ON', 'On')
        self.configureAndEnableHostHa()

        self.deployVM()

        # Start with the available state
        self.waitUntilHostInState("Available")

        # Kill host by triggering a fault
        self.killAgent()
        self.disableAgent()
        self.resetHost()

        # Check if host would go into Suspect state
        try:
            self.waitUntilHostInState("Suspect")
        except Exception as e:
            self.startAgent()
            raise Exception("Warning: Exception during test execution : %s" % e)

        # Checks if the host would turn into Recovered
        try:
            self.waitUntilHostInState("Recovered")
        except Exception as e:
            self.startAgent()
            raise Exception("Warning: Exception during test execution : %s" % e)

        self.enableAgent()
        self.startAgent()
        self.waitUntilHostInState("Available")

    @attr(tags=["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
    def test_hostha_kvm_host_fencing(self):
        """
            Tests fencing/fenced HA state when host crashes
        """
        self.logger.debug("Starting test_ha_kvm_host_fencing")

        self.skipIfMSIsUnsupported()
        self.configureAndStartIpmiServer()
        self.assertIssueCommandState('ON', 'On')
        self.configureAndEnableHostHa()

        self.deployVM()

        # Start with the available state
        self.waitUntilHostInState("Available")

        # Fail oobm commands
        cmd = self.getOobmConfigCmd()
        cmd.address = "1.1.1.1"
        self.apiclient.configureOutOfBandManagement(cmd)

        # Kill host by triggering a fault
        self.killAgent()
        self.disableAgent()
        self.resetHost()

        # Check if host would go into Suspect state
        try:
            self.waitUntilHostInState("Suspect")
        except Exception as e:
            self.startAgent()
            raise Exception("Warning: Exception during test execution : %s" % e)

        # Checks if the host would turn into Fencing
        try:
            self.waitUntilHostInState("Fencing")
        except Exception as e:
            self.startAgent()
            raise Exception("Warning: Exception during test execution : %s" % e)

        # Allow oobm commands to work now
        self.configureAndEnableOobm()

        # Checks if the host would turn into Fenced
        try:
            self.waitUntilHostInState("Fenced")
        except Exception as e:
            self.startAgent()
            raise Exception("Warning: Exception during test execution : %s" % e)

        self.enableAgent()
        self.startAgent()
        self.cancelMaintenance()
        self.waitUntilHostInState("Available")

    def configureAndStartIpmiServer(self, power_state=None):
        """
            Setup ipmisim and enable out-of-band management for host
        """
        self.configureAndEnableOobm()
        self.startIpmiServer()
        if power_state:
            bmc = IpmiServerContext().bmc
            bmc.powerstate = power_state

    def assertIssueCommandState(self, command, expected):
        """
            Asserts power action result for a given power command
        """
        if command != 'STATUS':
            self.issuePowerActionCmd(command)
        try:
            response = self.issuePowerActionCmd('STATUS')
            self.assertEqual(response.powerstate, expected)
        except:
            pass  # in case of ipmisim errors ignore

    def configureAndEnableOobm(self):
        self.apiclient.configureOutOfBandManagement(self.getOobmConfigCmd())
        response = self.apiclient.enableOutOfBandManagementForHost(self.getOobmEnableCmd())
        self.assertEqual(response.enabled, True)

    def startIpmiServer(self):
        def startIpmiServer(tname, server):
            self.debug("Starting ipmisim server")
            try:
                server.serve_forever()
            except Exception: pass
        IpmiServerContext('reset')
        ThreadedIpmiServer.allow_reuse_address = False
        server = ThreadedIpmiServer(('0.0.0.0', self.getIpmiServerPort()), IpmiServer)
        _thread.start_new_thread(startIpmiServer, ("ipmi-server", server,))
        self.server = server

    def stopIpmiServer(self):
        if self.server:
            self.server.shutdown()
            self.server.server_close()

    def getOobmIssueActionCmd(self):
        cmd = issueOutOfBandManagementPowerAction.issueOutOfBandManagementPowerActionCmd()
        cmd.hostid = self.host.id
        cmd.action = 'STATUS'
        return cmd

    def issuePowerActionCmd(self, action, timeout=None):
        cmd = self.getOobmIssueActionCmd()
        cmd.action = action
        if timeout:
            cmd.timeout = timeout

        try:
            return self.apiclient.issueOutOfBandManagementPowerAction(cmd)
        except Exception as e:
            if "packet session id 0x0 does not match active session" in str(e):
                raise self.skipTest("Known ipmitool issue hit, skipping test")
            raise e

    def getOobmEnableCmd(self):
        cmd = enableOutOfBandManagementForHost.enableOutOfBandManagementForHostCmd()
        cmd.hostid = self.host.id
        return cmd

    def getOobmDisableCmd(self):
        cmd = disableOutOfBandManagementForHost.disableOutOfBandManagementForHostCmd()
        cmd.hostid = self.host.id
        return cmd

    def getIpmiServerPort(self):
        return self.serverPort

    def getOobmConfigCmd(self):
        cmd = configureOutOfBandManagement.configureOutOfBandManagementCmd()
        cmd.driver = 'ipmitool' # The default available driver
        cmd.address = self.getIpmiServerIp()
        cmd.port = self.getIpmiServerPort()
        cmd.username = 'admin'
        cmd.password = 'password'
        cmd.hostid = self.host.id
        return cmd

    def getIpmiServerIp(self):
        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s.connect((self.mgtSvrDetails["mgtSvrIp"], self.mgtSvrDetails["port"]))
        return s.getsockname()[0]

    def get_non_configured_ha_host(self):

        response = list_hosts(
            self.apiclient,
            type='Routing'
        )

        for host in response:
            if host.haprovider is None:
                return host
            else:
                cloudstackTestCase.skipTest(self, "There is no non configured hosts. Skipping test.")

        raise self.skipTest("No KVM hosts found, skipping host-ha test")

    def getHAState(self, id):
        cmd = listHostHAResources.listHostHAResourcesCmd()
        cmd.hostid = id
        response = self.apiclient.listHostHAResources(cmd)

        return response[0]

    def startAgent(self):
        SshClient(host=self.host.ipaddress, port=22, user=self.hostConfig["username"],
                  passwd=self.hostConfig["password"]).execute \
            ("systemctl start cloudstack-agent || service cloudstack-agent start")

    def stopAgent(self):
        SshClient(host=self.host.ipaddress, port=22, user=self.hostConfig["username"],
                  passwd=self.hostConfig["password"]).execute \
            ("systemctl stop cloudstack-agent || service cloudstack-agent stop")

    def killAgent(self):
        SshClient(host=self.host.ipaddress, port=22, user=self.hostConfig["username"], passwd=self.hostConfig["password"]).execute\
            ("kill -9 $(ps aux | grep 'cloudstack-agent' | awk '{print $2}')")

    def disableHost(self, id):
        cmd = updateHost.updateHostCmd()
        cmd.id = id
        cmd.allocationstate = "Disable"
        response = self.apiclient.updateHost(cmd)
        self.assertEqual(response.resourcestate, "Disabled")

    def enableHost(self, id):
        cmd = updateHost.updateHostCmd()
        cmd.id = id
        cmd.allocationstate = "Enable"
        response = self.apiclient.updateHost(cmd)
        self.assertEqual(response.resourcestate, "Enabled")

    def setHostToMaintanance(self, id):
        cmd = prepareHostForMaintenance.prepareHostForMaintenanceCmd()
        cmd.id = id

        response = self.apiclient.prepareHostForMaintenance(cmd)

        self.assertEqual(response.resourcestate, "PrepareForMaintenance")

    def cancelMaintenance(self):
        cmd = cancelHostMaintenance.cancelHostMaintenanceCmd()
        cmd.id = self.host.id
        response = self.apiclient.cancelHostMaintenance(cmd)

        self.assertEqual(response.resourcestate, "Enabled")