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

Test cases relating to enabling/diabling of zone/pod/cluster/host

"""
#Import Local Modules
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 marvin.cloudstackException import CloudstackAclException
from nose.plugins.attrib import attr
#Import System modules
import time
import traceback


_multiprocess_shared_ = True

class TestOrganizationStates(cloudstackTestCase):

    @classmethod
    def setUpClass(cls):

	try:

            cls.testclient = super(TestOrganizationStates, cls).getClsTestClient()
            cls.apiclient = cls.testclient.getApiClient()
            cls.testdata = cls.testClient.getParsedTestDataConfig()
            cls.cleanup = []
	    zone = get_zone(cls.apiclient,cls.testclient.getZoneForTests())
	    cls.zone = Zone(zone.__dict__)	
	    cls.template = get_template(cls.apiclient, cls.zone.id, cls.testdata["ostype"])

	    hostList = Host.list(cls.apiclient,zoneid=cls.zone.id,type="routing")
	    cls.host = Host(hostList[0].__dict__)

	    clusterList = Cluster.list(cls.apiclient,id= hostList[0].clusterid)
	    cls.cluster = Cluster(clusterList[0].__dict__)
	  	
	    podList = Pod.list(cls.apiclient,id= hostList[0].podid)
	    cls.pod = Pod(podList[0].__dict__)
	    
	    cls.serviceOffering = ServiceOffering.create(
                                    cls.apiclient,
                                    cls.testdata["service_offering"],
				    hosttags="test"
                                    )

            hostupdResp = Host.update(cls.apiclient,
				      id=cls.host.id,
				      hosttags="test")
	    
	    userAccountName = "-".join(("TestOrgUser", random_gen()))
	    adminAccountName = "-".join(("TestOrgAdmin", random_gen()))
		

    	    cls.user_apiclient = cls.testclient.getUserApiClient(
                UserName=userAccountName,
                DomainName="ROOT"
            	)

    	    cls.admin_apiclient = cls.testclient.getUserApiClient(
                UserName=adminAccountName,
                DomainName="ROOT",
		type=1
            	)

            accountList = Account.list(
                cls.apiclient,
                name=userAccountName,
		listAll="true"
            )
	    cls.account = Account(accountList[0].__dict__)

            accountList = Account.list(
                cls.apiclient,
                name=adminAccountName,
		listAll="true"
            )
	    cls.adminAccount = Account(accountList[0].__dict__)

            cls.cleanup = [
                            cls.account,
                            cls.adminAccount,
                            cls.serviceOffering
                            ]

            cls.vm_admin = VirtualMachine.create(
                    cls.admin_apiclient,
		    {},
                    zoneid=cls.zone.id,
                    serviceofferingid=cls.serviceOffering.id,
                    templateid=cls.template.id
                )

            cls.vm_user = VirtualMachine.create(
                    cls.user_apiclient,
		    {},
                    zoneid=cls.zone.id,
                    serviceofferingid=cls.serviceOffering.id,
                    templateid=cls.template.id
                )

        except Exception as e:
	        printex = traceback.format_exc()
            	cls.debug("Exception Occurred : {0}".format(printex))
                cleanup_resources(cls.apiclient, cls.cleanup)
                raise Exception("Failed to create the setup required to execute the test cases: %s" % e)

    @classmethod
    def tearDownClass(cls):
        cls.apiclient = super(TestOrganizationStates, cls).getClsTestClient().getApiClient()
        hostupdResp = Host.update(cls.apiclient,
		      		id=cls.host.id,
			        hosttags="")
        cleanup_resources(cls.apiclient, cls.cleanup)
        return

    def setUp(cls):
	return

    def tearDown(cls):
	return

## Test cases relating to disabling and enabling zone

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_11_disableZone(self):
	"""
	Disable Zone
        Validate that listZones() returns the  allocationstate as "Disabled"
	"""
	self.debug("Zone to be disabled: " + self.zone.id)
	
	zoneupdResp = self.zone.update(self.apiclient,allocationstate="Disabled")

 	self.assertEqual(zoneupdResp.allocationstate,
                    "Disabled",
                    "Disabling Zone did not set the alloctionstate to Disabled")

	zonelistResp = Zone.list(self.apiclient,id=self.zone.id)

 	self.assertEqual(zonelistResp[0].allocationstate,
                    "Disabled",
                    "Disabling Zone did not set the alloctionstate to Disabled")


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_12_disableZone_admin_deployVM(self):
	"""
        Validate that admin is allowed to deploy VM in a disabled zone
	"""
        vm = VirtualMachine.create(
                    self.admin_apiclient,
                    {},
                    zoneid=self.zone.id,
                    serviceofferingid=self.serviceOffering.id,
                    templateid=self.template.id
                )

 	self.assertEqual(vm.state,
                    "Running",
                    "Admin is not able to deploy Vm in a disabled Zone! ")


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_13_disableZone_admin_stop_startVM(self):
	"""
        Validate that admin is allowed to stop and start existing VMs that are running on a disabled zone
	"""
        self.vm_admin.stop(self.apiclient)
	
	listResp = VirtualMachine.list(self.apiclient,id=self.vm_admin.id)
 	self.assertEqual(listResp[0].state,
                    VirtualMachine.STOPPED,
                    "Admin is not able to Stop Vm in a disabled Zone! ")

        self.vm_admin.start(self.apiclient)

	listResp = VirtualMachine.list(self.admin_apiclient,id=self.vm_admin.id)
 	self.assertEqual(listResp[0].state,
                    VirtualMachine.RUNNING,
                    "Admin is not able to Stop Vm in a disabled Zone! ")

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_14_disableZone_user_deployVM(self):
	"""
        Validate that regular user is not allowed to deploy VM in a disabled zone
	"""
	try:
            vm = VirtualMachine.create(
                    self.user_apiclient,
                    {},
                    zoneid=self.zone.id,
                    serviceofferingid=self.serviceOffering.id,
                    templateid=self.template.id
                )
            self.fail("Regular user is allowed to deploy VM in a zone that is disabled")
        except Exception as e:
                self.debug ("Exception thrown when deploying Virtual Machine on a disabled zone -  %s" %e)


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_15_disableZone_user_stop_startVM(self):
	"""
        Validate that regular user is allowed to stop and start existing VMs in a disabled zone
	"""
        self.vm_user.stop(self.user_apiclient)
	listResp = VirtualMachine.list(self.user_apiclient,id=self.vm_user.id)

 	self.assertEqual(listResp[0].state,
                    VirtualMachine.STOPPED,
                    "Regular user is not able to Stop Vm in a disabled Zone! ")

        self.vm_user.start(self.user_apiclient)
	listResp = VirtualMachine.list(self.user_apiclient,id=self.vm_user.id)

 	self.assertEqual(listResp[0].state,
                    VirtualMachine.RUNNING,
                    "Regular is not able to Stop Vm in a disabled Zone! ")

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_16_enableZone(self):
	"""
	Enable Zone that is diabled
        Validate that listZones() returns the  allocationstate as "Enabled"
	"""
	self.debug("Zone to be enabled: " + self.zone.id)
	
	zoneupdResp = self.zone.update(self.apiclient,allocationstate="Enabled")

 	self.assertEqual(zoneupdResp.allocationstate,
                    "Enabled",
                    "Enabling Zone did not set the alloctionstate to Enabled")

	zonelistResp = Zone.list(self.apiclient,id=self.zone.id)

 	self.assertEqual(zonelistResp[0].allocationstate,
                    "Enabled",
                    "Enabling Zone did not set the alloctionstate to Enabled")

## Test cases relating to disabling and enabling pod

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_21_disablePod(self):
	"""
	Disable Pod
        Validate that listPods() returns the  allocationstate as "Disabled"
	"""
	self.debug("Pod to be disabled: " + self.zone.id)
	
	podupdResp = self.pod.update(self.apiclient,allocationstate="Disabled")

 	self.assertEqual(podupdResp.allocationstate,
                    "Disabled",
                    "Disabling Pod did not set the alloctionstate to Disabled")

	podlistResp = Pod.list(self.apiclient,id=self.pod.id)

 	self.assertEqual(podlistResp[0].allocationstate,
                    "Disabled",
                    "Disabling Pod did not set the alloctionstate to Disabled")


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_22_disablePod_admin_deployVM(self):
	"""
        Validate that admin is allowed to deploy VM in a disabled pod
	"""
        vm = VirtualMachine.create(
                    self.admin_apiclient,
                    {},
                    zoneid=self.zone.id,
                    serviceofferingid=self.serviceOffering.id,
                    templateid=self.template.id
                )

 	self.assertEqual(vm.state,
                    "Running",
                    "Admin is not able to deploy Vm in a disabled Pod! ")


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_23_disablePod_admin_stop_startVM(self):
	"""
        Validate that admin is allowed to stop and start existing VMs running in a disabled pod
	"""
        self.vm_admin.stop(self.admin_apiclient)
	
	listResp = VirtualMachine.list(self.apiclient,id=self.vm_admin.id)
 	self.assertEqual(listResp[0].state,
                    VirtualMachine.STOPPED,
                    "Admin is not able to Stop Vm in a disabled Pod! ")

        self.vm_admin.start(self.admin_apiclient)

	listResp = VirtualMachine.list(self.apiclient,id=self.vm_admin.id)
 	self.assertEqual(listResp[0].state,
                    VirtualMachine.RUNNING,
                    "Admin is not able to Stop Vm in a disabled Pod! ")

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_24_disablePod_user_deployVM(self):
	"""
        Validate that regular user is not allowed to deploy VM in a disabled pod
	"""
	try:
            vm = VirtualMachine.create(
                    self.user_apiclient,
                    {},
                    zoneid=self.zone.id,
                    serviceofferingid=self.serviceOffering.id,
                    templateid=self.template.id
                )
            self.fail("Regular user is allowed to deploy VM in a zone that is disabled")
        except Exception as e:
                self.debug ("Exception thrown when deploying Virtual Machine on a disabled zone -  %s" %e)


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_25_disablePod_user_stop_startVM(self):
	"""
        Validate that regular user is allowed to stop and start existing VMs runing in a disabled pod
	"""
        self.vm_user.stop(self.user_apiclient)
	listResp = VirtualMachine.list(self.user_apiclient,id=self.vm_user.id)

 	self.assertEqual(listResp[0].state,
                    VirtualMachine.STOPPED,
                    "Regular user is not able to Stop Vm in a disabled Pod! ")

        self.vm_user.start(self.user_apiclient)
	listResp = VirtualMachine.list(self.user_apiclient,id=self.vm_user.id)

 	self.assertEqual(listResp[0].state,
                    VirtualMachine.RUNNING,
                    "Regular is not able to Stop Vm in a disabled Pod! ")

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_26_enablePod(self):
	"""
	Enable Pod that is diabled
        Validate that listPods() returns the  allocationstate as "Enabled"
	"""
	self.debug("Pod to be enabled: " + self.zone.id)
	
	podupdResp = self.pod.update(self.apiclient,allocationstate="Enabled")

 	self.assertEqual(podupdResp.allocationstate,
                    "Enabled",
                    "Enabling Pod did not set the alloctionstate to Enabled")

	podlistResp = Pod.list(self.apiclient,id=self.pod.id)

 	self.assertEqual(podlistResp[0].allocationstate,
                    "Enabled",
                    "Enabling Pod did not set the alloctionstate to Enabled")


## Test cases relating to disabling and enabling cluster

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_31_disableCluster(self):
	"""
	Disable Cluster
        Validate that listClusters() returns the  allocationstate as "Disabled"
	"""
	self.debug("Cluster to be disabled: " + self.cluster.id)
	
	clusterupdResp = self.cluster.update(self.apiclient,allocationstate="Disabled")

 	self.assertEqual(clusterupdResp.allocationstate,
                    "Disabled",
                    "Disabling Cluster did not set the alloctionstate to Disabled")

	clusterlistResp = Cluster.list(self.apiclient,id=self.cluster.id)

 	self.assertEqual(clusterlistResp[0].allocationstate,
                    "Disabled",
                    "Disabling Cluster did not set the alloctionstate to Disabled")


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_32_disableCluster_admin_deployVM(self):
	"""
        Validate that admin is allowed to deploy VM in a disabled cluster
	"""
        vm = VirtualMachine.create(
                    self.admin_apiclient,
                    {},
                    zoneid=self.zone.id,
                    serviceofferingid=self.serviceOffering.id,
                    templateid=self.template.id
                )

 	self.assertEqual(vm.state,
                    "Running",
                    "Admin is not able to deploy Vm in a disabled Cluster! ")


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_33_disableCluster_admin_stop_startVM(self):
	"""
        Validate that admin is allowed to stop and start existing VMs that are running in a disabled cluster
	"""
        self.vm_admin.stop(self.admin_apiclient)
	
	listResp = VirtualMachine.list(self.apiclient,id=self.vm_admin.id)
 	self.assertEqual(listResp[0].state,
                    VirtualMachine.STOPPED,
                    "Admin is not able to Stop Vm in a disabled Cluster! ")

        self.vm_admin.start(self.admin_apiclient)

	listResp = VirtualMachine.list(self.apiclient,id=self.vm_admin.id)
 	self.assertEqual(listResp[0].state,
                    VirtualMachine.RUNNING,
                    "Admin is not able to Stop Vm in a disabled Cluster! ")

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_34_disableCluster_user_deployVM(self):
	"""
        Validate that regular user is not allowed to deploy VM in a disabled cluster
	"""
	try:
            vm = VirtualMachine.create(
                    self.user_apiclient,
                    {},
                    zoneid=self.zone.id,
                    serviceofferingid=self.serviceOffering.id,
                    templateid=self.template.id
                )
            self.fail("Regular user is allowed to deploy VM in a cluster that is disabled")
        except Exception as e:
                self.debug ("Exception thrown when deploying Virtual Machine on a disabled cluster -  %s" %e)


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_35_disableCluster_user_stop_startVM(self):
	"""
        Validate that regular user is allowed to stop and start existing VMs that are running in a disabled cluster
	"""
        self.vm_user.stop(self.user_apiclient)
	listResp = VirtualMachine.list(self.user_apiclient,id=self.vm_user.id)

 	self.assertEqual(listResp[0].state,
                    VirtualMachine.STOPPED,
                    "Regular user is not able to Stop Vm in a disabled Cluster! ")

        self.vm_user.start(self.user_apiclient)
	listResp = VirtualMachine.list(self.user_apiclient,id=self.vm_user.id)

 	self.assertEqual(listResp[0].state,
                    VirtualMachine.RUNNING,
                    "Regular is not able to Stop Vm in a disabled Cluster! ")

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_36_enableCluster(self):
	"""
	Enable Cluster that is diabled
        Validate that listClusters() returns the  allocationstate as "Enabled"
	"""
	self.debug("Cluster to be enabled: " + self.cluster.id)
	
	clusterupdResp = self.cluster.update(self.apiclient,allocationstate="Enabled")

 	self.assertEqual(clusterupdResp.allocationstate,
                    "Enabled",
                    "Enabling Cluster did not set the alloctionstate to Enabled")

	clusterlistResp = Cluster.list(self.apiclient,id=self.cluster.id)

 	self.assertEqual(clusterlistResp[0].allocationstate,
                    "Enabled",
                    "Enabling Cluster did not set the alloctionstate to Enabled")

## Test cases relating to disabling and enabling host

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_41_disableHost(self):
	"""
	Disable Host
        Validate that listHosts() returns the  allocationstate as "Disabled"
	"""
	self.debug("Host to be disabled: " + self.host.id)
	
	hostupdResp = Host.update(self.apiclient,id=self.host.id,allocationstate="Disable")

 	self.assertEqual(hostupdResp.resourcestate,
                    "Disabled",
                    "Disabling Host did not set the alloctionstate to Disabled")

	hostlistResp = Host.list(self.apiclient,id=self.host.id)

 	self.assertEqual(hostlistResp[0].resourcestate,
                    "Disabled",
                    "Disabling Host did not set the alloctionstate to Disabled")


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_42_disableHost_admin_deployVM(self):
	"""
        Validate that admin is allowed to deploy VM in a disabled host by passing hostId parameter
	"""
        vm = VirtualMachine.create(
                    self.admin_apiclient,
                    {},
                    zoneid=self.zone.id,
                    serviceofferingid=self.serviceOffering.id,
                    templateid=self.template.id,
		    hostid=self.host.id
                )

 	self.assertEqual(vm.state,
                    "Running",
                    "Admin is not able to deploy Vm in a disabled Host! ")


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_43_disableHost_admin_deployVM(self):
	"""
        Validate that admin is allowed to deploy VM in a disabled host without passing hostId parameter
	"""
        vm = VirtualMachine.create(
                    self.admin_apiclient,
                    {},
                    zoneid=self.zone.id,
                    serviceofferingid=self.serviceOffering.id,
                    templateid=self.template.id
                )

 	self.assertEqual(vm.state,
                    "Running",
                    "Admin is not able to deploy Vm in a disabled Host! ")


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_44_disableHost_admin_stop_startVM(self):
	"""
        Validate that admin is allowed to stop and start existing VMs running in a disabled host
	"""
        self.vm_admin.stop(self.admin_apiclient)
	
	listResp = VirtualMachine.list(self.apiclient,id=self.vm_admin.id)
 	self.assertEqual(listResp[0].state,
                    VirtualMachine.STOPPED,
                    "Admin is not able to Stop Vm in a disabled Host! ")

        self.vm_admin.start(self.admin_apiclient)

	listResp = VirtualMachine.list(self.apiclient,id=self.vm_admin.id)
 	self.assertEqual(listResp[0].state,
                    VirtualMachine.RUNNING,
                    "Admin is not able to Stop Vm in a disabled Host! ")

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_45_disableHost_user_deployVM(self):
	"""
        Validate that regular user is not allowed to deploy VM in a disabled host
	"""
	try:
            vm = VirtualMachine.create(
                    self.user_apiclient,
                    {},
                    zoneid=self.zone.id,
                    serviceofferingid=self.serviceOffering.id,
                    templateid=self.template.id
                )
            self.fail("Regular user is allowed to deploy VM in a host that is disabled")
        except Exception as e:
                self.debug ("Exception thrown when deploying Virtual Machine on a disabled host -  %s" %e)


    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_46_disableHost_user_stop_startVM(self):
	"""
        Validate that regular user is allowed to stop and start existing VMs running in a disabled host
	"""
        self.vm_user.stop(self.user_apiclient)
	listResp = VirtualMachine.list(self.user_apiclient,id=self.vm_user.id)

 	self.assertEqual(listResp[0].state,
                    VirtualMachine.STOPPED,
                    "Regular user is not able to Stop Vm in a disabled Host! ")

        self.vm_user.start(self.user_apiclient)
	listResp = VirtualMachine.list(self.user_apiclient,id=self.vm_user.id)

 	self.assertEqual(listResp[0].state,
                    VirtualMachine.RUNNING,
                    "Regular is not able to Stop Vm in a disabled Host! ")

    @attr("disruptive","simulator_only",tags=["advanced"],required_hardware="false")
    def test_47_enableHost(self):
	"""
	Enable Host that is diabled
        Validate that listHosts() returns the  allocationstate as "Enabled"
	"""
	self.debug("Host to be enabled: " + self.host.id)
	
	hostupdResp = Host.update(self.apiclient,id=self.host.id,allocationstate="Enable")

 	self.assertEqual(hostupdResp.resourcestate,
                    "Enabled",
                    "Enabling Host did not set the alloctionstate to Enabled")

	hostlistResp = Host.list(self.apiclient,id=self.host.id)

 	self.assertEqual(hostlistResp[0].resourcestate,
                    "Enabled",
                    "Enabling Host did not set the alloctionstate to Enabled")


