package org.zstack.test.integration.kvm.lifecycle

import org.springframework.http.HttpEntity
import org.zstack.header.vm.VmInstanceState
import org.zstack.header.vm.VmInstanceVO
import org.zstack.kvm.KVMAgentCommands
import org.zstack.kvm.KVMConstant
import org.zstack.sdk.VmInstanceInventory
import org.zstack.test.integration.kvm.OneVmBasicEnv
import org.zstack.testlib.EnvSpec
import org.zstack.testlib.SubCase
import org.zstack.testlib.VmSpec
import org.zstack.utils.gson.JSONObjectUtil

class OneVmBasicLifeCycleCase extends SubCase {
    EnvSpec env

    def DOC = """
test a VM's start/stop/reboot/destroy/recover operations 
"""

    @Override
    void setup() {
        spring {
            sftpBackupStorage()
            localStorage()
            virtualRouter()
            securityGroup()
            kvm()
        }
    }

    @Override
    void environment() {
        env = OneVmBasicEnv.env()
    }

    @Override
    void test() {
        env.create {
            testStopVm()
            testStartVm()
            testRebootVm()
            testDestroyVm()
            testRecoverVm()
        }
    }

    void testRecoverVm() {
        VmSpec spec = env.specByName("vm")

        VmInstanceInventory inv = recoverVmInstance {
            uuid = spec.inventory.uuid
        }

        assert inv.state == VmInstanceState.Stopped.toString()

        // confirm the vm can start after being recovered
        testStartVm()
    }

    void testDestroyVm() {
        VmSpec spec = env.specByName("vm")

        KVMAgentCommands.DestroyVmCmd cmd = null

        env.afterSimulator(KVMConstant.KVM_DESTROY_VM_PATH) { rsp, HttpEntity<String> e ->
            cmd = JSONObjectUtil.toObject(e.body, KVMAgentCommands.DestroyVmCmd.class)
            return rsp
        }

        destroyVmInstance {
            uuid = spec.inventory.uuid
        }

        assert cmd != null
        assert cmd.uuid == spec.inventory.uuid
        VmInstanceVO vmvo = dbFindByUuid(cmd.uuid, VmInstanceVO.class)
        assert vmvo.state == VmInstanceState.Destroyed
    }

    void testRebootVm() {
        // reboot = stop + start
        VmSpec spec = env.specByName("vm")

        KVMAgentCommands.StartVmCmd startCmd = null
        KVMAgentCommands.StopVmCmd stopCmd = null

        env.afterSimulator(KVMConstant.KVM_STOP_VM_PATH) { rsp, HttpEntity<String> e ->
            stopCmd = JSONObjectUtil.toObject(e.body, KVMAgentCommands.StopVmCmd.class)
            return rsp
        }

        env.afterSimulator(KVMConstant.KVM_START_VM_PATH) { rsp, HttpEntity<String> e ->
            startCmd = JSONObjectUtil.toObject(e.body, KVMAgentCommands.StartVmCmd.class)
            return rsp
        }

        VmInstanceInventory inv = rebootVmInstance {
            uuid = spec.inventory.uuid
        }

        assert startCmd != null
        assert startCmd.vmInstanceUuid == spec.inventory.uuid
        assert stopCmd != null
        assert stopCmd.uuid == spec.inventory.uuid
        assert inv.state == VmInstanceState.Running.toString()
    }

    void testStartVm() {
        VmSpec spec = env.specByName("vm")

        KVMAgentCommands.StartVmCmd cmd = null

        env.afterSimulator(KVMConstant.KVM_START_VM_PATH) { rsp, HttpEntity<String> e ->
            cmd = JSONObjectUtil.toObject(e.body, KVMAgentCommands.StartVmCmd.class)
            return rsp
        }

        VmInstanceInventory inv = startVmInstance {
            uuid = spec.inventory.uuid
        }

        assert cmd != null
        assert cmd.vmInstanceUuid == spec.inventory.uuid
        assert inv.state == VmInstanceState.Running.toString()

        VmInstanceVO vmvo = dbFindByUuid(cmd.vmInstanceUuid, VmInstanceVO.class)
        assert vmvo.state == VmInstanceState.Running
        assert cmd.vmInternalId == vmvo.internalId
        assert cmd.vmName == vmvo.name
        assert cmd.memory == vmvo.memorySize
        assert cmd.cpuNum == vmvo.cpuNum
        //TODO: test socketNum, cpuOnSocket
        assert cmd.rootVolume.installPath == vmvo.rootVolumes.installPath
        assert cmd.useVirtio
        vmvo.vmNics.each { nic ->
            KVMAgentCommands.NicTO to = cmd.nics.find { nic.mac == it.mac }
            assert to != null: "unable to find the nic[mac:${nic.mac}]"
            assert to.deviceId == nic.deviceId
            assert to.useVirtio
            assert to.nicInternalName == nic.internalName
        }
    }

    void testStopVm() {
        VmSpec spec = env.specByName("vm")

        KVMAgentCommands.StopVmCmd cmd = null

        env.afterSimulator(KVMConstant.KVM_STOP_VM_PATH) { rsp, HttpEntity<String> e ->
            cmd = JSONObjectUtil.toObject(e.body, KVMAgentCommands.StopVmCmd.class)
            return rsp
        }

        VmInstanceInventory inv = stopVmInstance {
            uuid = spec.inventory.uuid
        }

        assert inv.state == VmInstanceState.Stopped.toString()

        assert cmd != null
        assert cmd.uuid == spec.inventory.uuid

        def vmvo = dbFindByUuid(cmd.uuid, VmInstanceVO.class)
        assert vmvo.state == VmInstanceState.Stopped
    }

    @Override
    void clean() {
        env.delete()
    }
}

class OneVmBasicLifeCycleCase extends SubCase {

    @Override
    void setup() {
        spring {
            sftpBackupStorage()
            localStorage()
            virtualRouter()
            securityGroup()
            kvm()
        }
    }

    @Override
    void setup() {
        spring {
            include("Kvm.xml") //指定XML文件名即可，不需要加路径
            include("eip.xml")
        }
    }

    @Override
    void setup() {
        spring {
            // 虽然没有指定任何XML，spring DSL仍然会为我们加载核心服务
        }
    }

    List<String> CORE_SERVICES = [
            "HostManager.xml",
            "ZoneManager.xml",
            "ClusterManager.xml",
            "PrimaryStorageManager.xml",
            "BackupStorageManager.xml",
            "ImageManager.xml",
            "HostAllocatorManager.xml",
            "ConfigurationManager.xml",
            "VolumeManager.xml",
            "NetworkManager.xml",
            "VmInstanceManager.xml",
            "AccountManager.xml",
            "NetworkService.xml",
            "volumeSnapshot.xml",
            "tag.xml",
    ]

    @Override
    void setup() {
        INCLUDE_CORE_SERVICES = false //当该变量设置成false后，后续的spring DSL不会自动加载核心服务

        spring {
            include("ZoneManager.xml") //这里我们只加载跟zone相关的服务
        }
    }

    EnvSpec myenv

    @Override
    void environment() {
        myenv = env {
            zone {
                name = "zone"

                l2NoVlanNetwork {
                    name = "l2"
                    physicalInterface = "eth0"

                    l3Network {
                        name = "l3"

                        ip {
                            name = "ipr"
                            startIp = "10.223.110.10"
                            endIp = "10.223.110.20"
                            gateway = "10.223.110.1"
                            netmask = "255.255.255.0"
                        }
                    }
                }
            }
        }
    }

  @Override
  void test() {
     myenv.create()
  }

                virtualRouterOffering {
                    name = "vr"
                    memory = SizeUnit.MEGABYTE.toByte(512)
                    cpu = 2
                    useManagementL3Network("pubL3")
                    usePublicL3Network("pubL3")
                    useImage("vr")
                    useAccount("xin")
                }

                cluster {
                    name = "cluster"
                    hypervisorType = "KVM"

                    kvm {
                        name = "kvm"
                        managementIp = "localhost"
                        username = "root"
                        password = "password"
                        usedMem = 1000
                        totalCpu = 10
                    }

                    attachPrimaryStorage("nfs", "ceph-pri", "local", "smp")
                    attachL2Network("l2")
                }

class OneL3OneIpRangeNoIpUsed extends SubCase {
    EnvSpec env
    
    @Override
    void environment() {
        env = env {
            //在这里描述环境
        }
    }
    
    @Override
    void test() {
        env.create {
            //这里执行测试逻辑
        }
    }
}

    void useIpRangeUuidWithStartBeyondTheEndIp() {
        IpRangeSpec ipr = env.specByName("ipr")

        List<FreeIpInventory> freeIps = getFreeIpOfIpRange {
            ipRangeUuid = ipr.inventory.uuid
            start = "10.223.110.21"
        }

        assert freeIps.size() == 0
    }

    void testStopVm() {
        VmSpec spec = env.specByName("vm")

        KVMAgentCommands.StopVmCmd cmd = null

        env.afterSimulator(KVMConstant.KVM_STOP_VM_PATH) { rsp, HttpEntity<String> e ->
            cmd = JSONObjectUtil.toObject(e.body, KVMAgentCommands.StopVmCmd.class)
            return rsp
        }

        VmInstanceInventory inv = stopVmInstance {
            uuid = spec.inventory.uuid
        }

        assert inv.state == VmInstanceState.Stopped.toString()

        assert cmd != null
        assert cmd.uuid == spec.inventory.uuid

        def vmvo = dbFindByUuid(cmd.uuid, VmInstanceVO.class)
        assert vmvo.state == VmInstanceState.Stopped
    }

    void testRecoverVm() {
        VmSpec spec = env.specByName("vm")

        VmInstanceInventory inv = recoverVmInstance {
            uuid = spec.inventory.uuid
        }

        assert inv.state == VmInstanceState.Stopped.toString()

        // confirm the vm can start after being recovered
        testStartVm()
    }

StartVmInstanceAction a = new StartVmInstanceAction()
a.sessionId = "583c56b6352d4399aac23295b1507506"
a.uuid = "36c27e8ff05c4780bf6d2fa65700f22e"
StartVmInstanceAction.Result res = a.call()
assert res.error != null: "API StartVmInstanceAction fails with an error ${res.error}"
VmInstanceInventory vm = res.value.inventory

VmInstanceInventory inv = startVmInstance {
     uuid = "36c27e8ff05c4780bf6d2fa65700f22e"
     sessionId = "583c56b6352d4399aac23295b1507506"
}

    expect(RuntimeException.class) {
        throw new RuntimeException("ok")
    }

    expect([CloudRuntimeException.class, IllegalArgumentException.class]) {
        throw new RuntimeException("ok")
    }

    expect(AssertionError.class) {
        VmInstanceInventory inv = startVmInstance {
            uuid = "36c27e8ff05c4780bf6d2fa65700f22e"
            sessionId = "583c56b6352d4399aac23295b1507506"
        }
    }

assert inv.state == VmInstanceState.Stopped.toString()

env.simulator(KVMConstant.KVM_START_VM_PATH) {
    throw new Exception("fail to start a VM on purpose")
}

void testStartVm() {
    VmSpec spec = env.specByName("vm")

    KVMAgentCommands.StartVmCmd cmd = null

    env.afterSimulator(KVMConstant.KVM_START_VM_PATH) { rsp, HttpEntity<String> e ->
        cmd = JSONObjectUtil.toObject(e.body, KVMAgentCommands.StartVmCmd.class)
        return rsp
    }

    VmInstanceInventory inv = startVmInstance {
        uuid = spec.inventory.uuid
    }

    assert cmd != null
    assert cmd.vmInstanceUuid == spec.inventory.uuid
    assert inv.state == VmInstanceState.Running.toString()

    VmInstanceVO vmvo = dbFindByUuid(cmd.vmInstanceUuid, VmInstanceVO.class)
    assert vmvo.state == VmInstanceState.Running
    assert cmd.vmInternalId == vmvo.internalId
    assert cmd.vmName == vmvo.name
    assert cmd.memory == vmvo.memorySize
    assert cmd.cpuNum == vmvo.cpuNum
    //TODO: test socketNum, cpuOnSocket
    assert cmd.rootVolume.installPath == vmvo.rootVolumes.installPath
    assert cmd.useVirtio
    vmvo.vmNics.each { nic ->
        KVMAgentCommands.NicTO to = cmd.nics.find { nic.mac == it.mac }
        assert to != null: "unable to find the nic[mac:${nic.mac}]"
        assert to.deviceId == nic.deviceId
        assert to.useVirtio
        assert to.nicInternalName == nic.internalName
    }
}

// httpPath: agent的HTTP RPC路径，例如上例中的KVM_START_VM_PATH = "/vm/start"
// handler: 处理HTTP RPC调用的函数
void simulator(String httpPath, Closure handler)

// handler作为groovy Closure类型可以接收两个可选参数：
// entity：HTTP request，可以获得HTTP header和body
// spec: 该handler挂载的EnvSpec，可以通过它获得其它资源的spec
// 返回值：返回给HTTP PRC调用的response，如果该HTTP RPC不需要返回值，则返回一个空map：[:]或null。
def handler = { HttpEntity<String> entity, EnvSpec spec ->
    return [:]
}

// httpPath: agent的HTTP RPC路径，例如上例中的KVM_START_VM_PATH = "/vm/start"
// handler: 需要在系统默认handler执行后被调用的函数
void afterSimulator(String httpPath, Closure handler)

// handler可以接收三个可选参数
// response: 系统默认handler返回的response对象
// entity：HTTP request，可以获得HTTP header和body
// spec: 该handler挂载的EnvSpec，可以通过它获得其它资源的spec
// 返回值：返回给HTTP PRC调用的response，如果该HTTP RPC不需要返回值，则返回一个空map：[:]或null。
def handler = { Object response, HttpEntity<String> entity, EnvSpec spec ->
    return response
}

env.simulator(KVMConstant.KVM_START_VM_PATH) {
    throw new HttpError(403, "fail to start a VM on purpose")
}

@Override
void test() {
    ErrorFacade errf = bean(ErrorFacade.class)

    env.message(StartNewCreatedVmInstanceMsg.class) { StartNewCreatedVmInstanceMsg msg, CloudBus bus ->
        def reply = new MessageReply()
        reply.setError(errf.stringToOperationError("on purpose"))
        bus.reply(msg, reply)
    }
}

@Override
void test() {
    ErrorFacade errf = bean(ErrorFacade.class)

    message(StartNewCreatedVmInstanceMsg.class, { StartNewCreatedVmInstanceMsg msg ->
        return msg.vmInstanceInventory.name == "web"
    }) { StartNewCreatedVmInstanceMsg msg, CloudBus bus ->
        def reply = new MessageReply()
        reply.setError(errf.stringToOperationError("on purpose"))
        bus.reply(msg, reply)
    }
}

// msgClz: 要捕获消息的类型
// condition: 条件函数，当函数返回true时，消息才会被捕获并执行handler
// handler: 处理被捕获消息的函数
void message(Class<? extends Message> msgClz, Closure condition, Closure handler)

// condition接收一个可选参数
// msg: 被捕获的消息
// 返回值： true捕获消息，false不捕获消息
def condition = { Message msg ->
    return true
}

// handler接收两个可选参数
// msg: 被捕获的消息
// bus: CloudBus对象
// 无返回值
def handler = { Message msg, CloudBus bus ->
}

@Override
void test() {
    env.create {
        testStopVm()
        testStartVm()
        testRebootVm()
        testDestroyVm()
        testRecoverVm()
    }
}

@Override
void clean() {
    env.delete()
}

class GetFreeIpTest extends Test {
    def DOC = """

    Test getting free IPs from a single L3 network with one or two IP ranges
    
"""
    @Override
    void setup() {
        spring {
            include("vip.xml")
        }
    }

    @Override
    void environment() {
    }

    @Override
    void test() {
        runSubCases()
    }
}

class OneVmBasicEnv {
    def DOC = """
use:
1. sftp backup storage
2. local primary storage
3. virtual router provider
4. l2 novlan network
5. security group
"""

    static EnvSpec env() {
        return Test.makeEnv {
            instanceOffering {
                name = "instanceOffering"
                memory = SizeUnit.GIGABYTE.toByte(8)
                cpu = 4
            }

            sftpBackupStorage {
                name = "sftp"
                url = "/sftp"
                username = "root"
                password = "password"
                hostname = "localhost"

                image {
                    name = "image1"
                    url  = "http://zstack.org/download/test.qcow2"
                }

                image {
                    name = "vr"
                    url  = "http://zstack.org/download/vr.qcow2"
                }
            }

            zone {
                name = "zone"
                description = "test"

                cluster {
                    name = "cluster"
                    hypervisorType = "KVM"

                    kvm {
                        name = "kvm"
                        managementIp = "localhost"
                        username = "root"
                        password = "password"
                    }

                    attachPrimaryStorage("local")
                    attachL2Network("l2")
                }

                localPrimaryStorage {
                    name = "local"
                    url = "/local_ps"
                }

                l2NoVlanNetwork {
                    name = "l2"
                    physicalInterface = "eth0"

                    l3Network {
                        name = "l3"

                        service {
                            provider = VirtualRouterConstant.PROVIDER_TYPE
                            types = [NetworkServiceType.DHCP.toString(), NetworkServiceType.DNS.toString()]
                        }

                        service {
                            provider = SecurityGroupConstant.SECURITY_GROUP_PROVIDER_TYPE
                            types = [SecurityGroupConstant.SECURITY_GROUP_NETWORK_SERVICE_TYPE]
                        }

                        ip {
                            startIp = "192.168.100.10"
                            endIp = "192.168.100.100"
                            netmask = "255.255.255.0"
                            gateway = "192.168.100.1"
                        }
                    }

                    l3Network {
                        name = "pubL3"

                        ip {
                            startIp = "12.16.10.10"
                            endIp = "12.16.10.100"
                            netmask = "255.255.255.0"
                            gateway = "12.16.10.1"
                        }
                    }
                }

                virtualRouterOffering {
                    name = "vr"
                    memory = SizeUnit.MEGABYTE.toByte(512)
                    cpu = 2
                    useManagementL3Network("pubL3")
                    usePublicL3Network("pubL3")
                    useImage("vr")
                }

                attachBackupStorage("sftp")
            }

            vm {
                name = "vm"
                useInstanceOffering("instanceOffering")
                useImage("image1")
                useL3Networks("l3")
            }
        }
    }
}

class OneVmBasicLifeCycleCase extends SubCase {
    EnvSpec env

    def DOC = """
test a VM's start/stop/reboot/destroy/recover operations 
""" 

    @Override
    void environment() {
        env = OneVmBasicEnv.env()
    }

env = env {
    zone {
        resourceUuid = "14d087f6d59a4d639094e6c2c9032161"
        name = "zone1"
    }
}

            DataCenterSpec dcSpec = dataCenter {
                regionId = "cn-hangzhou"
                type = "aliyun"
                description = "createEcsEnv test"
                dcName = "Test-Region-Name"
                vpc = ecsVpc {
                    vpcName = "Test-Vpc-Name"
                    description = "Test-Vpc"
                    cidrBlock = "192.168.0.0/16"
                    vpcId = "Test-Vpc-Id"
                    VRouterId = "Test-VRouter-Id"
                    vrouter = vRouter {
                        vrId = "Test-VRouter-Id"
                        vRouterName = "Test-VRouter-Name"
                        description = "Test-VRouter"
                    }
                }
                postCreate {
                    attachToOssBucket(ossSpeck.inventory.uuid)
                }
            }

            DataCenterSpec dcSpec = dataCenter {
                regionId = "cn-hangzhou"
                type = "aliyun"
                description = "createEcsEnv test"
                dcName = "Test-Region-Name"
                vpc = ecsVpc {
                    onlyDefine = true   // 只需在这里设置true即可
                    vpcName = "Test-Vpc-Name"
                    description = "Test-Vpc"
                    cidrBlock = "192.168.0.0/16"
                    vpcId = "Test-Vpc-Id"
                    VRouterId = "Test-VRouter-Id"
                    vrouter = vRouter {
                        onlyDefine = true    // 只需在这里设置true即可
                        vrId = "Test-VRouter-Id"
                        vRouterName = "Test-VRouter-Name"
                        description = "Test-VRouter"
                    }
                }
                postCreate {
                    attachToOssBucket(ossSpeck.inventory.uuid)
                }
            }

(in EcsVpcSpec.groovy)
    @Override
    SpecID define(String uuid) {
        inventory = new EcsVpcInventory()
        inventory.uuid = uuid
        inventory.vpcName = vpcName
        inventory.ecsVpcId = vpcId
        inventory.cidrBlock = cidrBlock
        inventory.description = description
        inventory.vRouterId = VRouterId
        inventory.status = "Available"

        return id(inventory.vpcName, inventory.uuid)
    }

(in VRouterSpec.groovy)
    @Override
    SpecID define(String uuid) {
        inventory = new VpcVirtualRouterInventory()
        inventory.uuid = uuid
        inventory.vRouterName = vRouterName
        inventory.description = description
        inventory.vrId = vrId
        return id(inventory.vRouterName, inventory.uuid)
    }

(in VRouterSpec.groovy)
    private void setupSimulator() {
        message(SyncVpcPropertyMsg.class) { SyncVpcPropertyMsg msg, CloudBus bus ->
            SyncVpcPropertyReply reply = new SyncVpcPropertyReply()
            def property = new EcsVpcProperty()
            property.ecsVpcId = inventory.ecsVpcId
            property.status = inventory.status
            property.vpcName = inventory.vpcName
            property.cidrBlock = inventory.cidrBlock
            property.vRouterId = inventory.vRouterId
            property.description = inventory.description
            reply.setVpcs(Arrays.asList(property))
            bus.reply(msg, reply)
        }
    }

    @Override
    void test() {
        // envSpec 为env DSL创建的EnvSpec对象
        envSpec.create {
            DiskOfferingSpec diskOfferingSpec = envSpec.specByName("diskOffering")
            ZoneSpec zone = envSpec.specsByUuid("14d087f6d59a4d639094e6c2c9032161")
        }
    }

@Override
void test() {
    ErrorFacade errf = bean(ErrorFacade.class)
    DatabaseFacade dbf = bean(DatabaseFacade.class)
}

void testStartVm() {
    VmInstanceVO vmvo = dbFindByUuid(cmd.vmInstanceUuid, VmInstanceVO.class)
    assert vmvo.state == VmInstanceState.Running
}

void testStartVm() {
    DatabaseFacade dbf = bean(DatabaseFacade.class)
    VmInstanceVO vmvo = dbf.findByUuid(cmd.vmInstanceUuid, VmInstanceVO.class)
    assert vmvo.state == VmInstanceState.Running
}

// env为EnvSpec对象

env.cleanSimulatorAndMessageHandlers()
env.cleanSimulatorHandlers()
env.cleanAfterSimulatorHandlers()
env.cleanMessageHandlers()

        env.afterSimulator(FlatUserdataBackend.RELEASE_USER_DATA) { rsp, HttpEntity<String> e ->
            cmd = json(e.body, FlatUserdataBackend.ReleaseUserdataCmd.class)
            return rsp
        }

  @Override
    void test() {
        env.create {
            // Global Config必须在这里修改
            // make the interval very long, we use api to trigger the job to test
            ImageGlobalConfig.DELETION_GARBAGE_COLLECTION_INTERVAL.updateValue(TimeUnit.DAYS.toSeconds(1))

            testImageGCWhenBackupStorageDisconnect()

            env.recreate("image")

            testImageGCCancelledAfterBackupStorageDeleted()
        }
    }

    @Override
    void test() {
        env.create {
            testGCSuccess()
            testGCCancelledAfterHostDeleted()

            //这里 testGCCancelledAfterHostDeleted() 删除了名为kvm的host，我们
            //用env.recreate()重建它供testGCCancelledAfterPrimaryStorageDeleted()使用
            env.recreate("kvm")

            testGCCancelledAfterPrimaryStorageDeleted()
        }
    }

/*
EnvSpec env = env {
        zone {
            name = "zone"
        }

        sftpBackupStorage {
            name = "sftp"
            url = "/sftp"

            image {
                name = "image"
                url = "http://zstack.org/download/image.qcow2"
            }
        }
}
*/

ImageInventory image = env.inventoryByName("image")

    boolean ret = retryInSecs(3, 1) {
        // 在这里执行操作结果检测
        // 检测成功返回true，则retryInSecs会直接返回true，表示检测成功；
        // 返回false，retryInSecs会sleep指定interval后（第二个参数，这里为1s）后再次执行该检测函数。
        // 如果在指定间隔时间（第一个参数，这里为3s)检测函数都返回false，retryInSecs返回false，表示检测失败
        return true
    }