# 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.
""" P1 tests for Browser Based Upload Volumes
"""
# Import Local Modules

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

import requests
import random
import string
import time
_multiprocess_shared_ = True

class TestBrowseUploadVolume(cloudstackTestCase):

    """
    Testing Browse Upload Volume Feature
    """
    @classmethod
    def setUpClass(cls):
        cls.testClient = super(TestBrowseUploadVolume,cls).getClsTestClient()
        #print cls.testClient.getParsedTestDataConfig()
        cls.testdata = cls.testClient.getParsedTestDataConfig()
        cls.apiclient = cls.testClient.getApiClient()
        cls.hypervisor = cls.testClient.getHypervisorInfo()
        cls._cleanup = []
        cls.domain = get_domain(cls.apiclient)
        cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
        cls.unsupportedHypervisor = False
        hosts = list_hosts(
            cls.apiclient,
            type="Routing"
        )

        if cls.hypervisor.lower() in ['lxc']:
            # Template creation from root volume is not supported in LXC
            cls.unsupportedHypervisor = True
            return

        if hosts is None:
            raise unittest.SkipTest(
                "There are no hypervisor's available.Check listhosts response")

        cls.account = Account.create(
            cls.apiclient,
            cls.testdata["account"],
            domainid=cls.domain.id
        )
        cls._cleanup.append(cls.account)

        cls.template = get_template(
            cls.apiclient,
            cls.zone.id)

        if cls.template == FAILED:
                raise unittest.SkipTest(
                    "Check for default cent OS template readiness ")

        cls.service_offering = ServiceOffering.create(
            cls.apiclient,
            cls.testdata["service_offering"]
        )
        cls._cleanup.append(cls.service_offering)
        cls.disk_offering = DiskOffering.create(
            cls.apiclient,
            cls.testdata["resized_disk_offering"],
            custom=True
        )
        cls._cleanup.append(cls.disk_offering)
        cls.project = Project.create(
                                 cls.apiclient,
                                 cls.testdata["project"],
                                 account=cls.account.name,
                                 domainid=cls.account.domainid
                                 )
        cls._cleanup.append(cls.project)

    def setUp(self):

        if "kvm" in self.hypervisor.lower():
            self.test_template = registerTemplate.registerTemplateCmd()
            self.test_template = registerTemplate.registerTemplateCmd()
            self.test_template.checksum = "{SHA-1}" + "bf580a13f791d86acf3449a7b457a91a14389264"
            self.test_template.hypervisor = self.hypervisor
            self.test_template.zoneid = self.zone.id
            self.test_template.name = 'test sha-1'
            self.test_template.displaytext = 'test sha-1'
            self.test_template.url = "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-kvm.qcow2.bz2"
            self.test_template.format = "QCOW2"
            self.test_template.ostypeid = self.getOsType("Other Linux (64-bit)")
            self.md5 = "ada77653dcf1e59495a9e1ac670ad95f"
            self.sha256 = "0efc03633f2b8f5db08acbcc5dc1be9028572dfd8f1c6c8ea663f0ef94b458c5"

        if "vmware" in self.hypervisor.lower():
            self.test_template = registerTemplate.registerTemplateCmd()
            self.test_template = registerTemplate.registerTemplateCmd()
            self.test_template.checksum = "{SHA-1}" + "b25d404de8335b4348ff01e49a95b403c90df466"
            self.test_template.hypervisor = self.hypervisor
            self.test_template.zoneid = self.zone.id
            self.test_template.name = 'test sha-2333'
            self.test_template.displaytext = 'test sha-1'
            self.test_template.url = "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-vmware.ova"
            self.test_template.format = "OVA"
            self.test_template.ostypeid = self.getOsType(self, "Other Linux (64-bit)")
            self.md5 = "d6d97389b129c7d898710195510bf4fb"
            self.sha256 = "f57b59f118ab59284a70d6c63229d1de8f2d69bffc5a82b773d6c47e769c12d9"

        if "xen" in self.hypervisor.lower():
            self.test_template = registerTemplate.registerTemplateCmd()
            self.test_template = registerTemplate.registerTemplateCmd()
            self.test_template.checksum = "{SHA-1}" + "427fad501d0d8a1d63b8600a9a469fbf91191314"
            self.test_template.hypervisor = self.hypervisor
            self.test_template.zoneid = self.zone.id
            self.test_template.name = 'test sha-2333'
            self.test_template.displaytext = 'test sha-1'
            self.test_template.url = "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-xen.vhd.bz2"
            self.test_template.format = "VHD"
            self.test_template.ostypeid = self.getOsType("Other Linux (64-bit)")
            self.md5 = "54ebc933e6e07ae58c0dc97dfd37c824"
            self.sha256 = "bddd9876021d33df9792b71ae4b776598680ac68ecf55e9d9af33c80904cc1f3"

        if self.unsupportedHypervisor:
            self.skipTest("Skipping test because unsupported hypervisor\
                            %s" % self.hypervisor)

        self.cleanup = []

    def getOsType(self, param):
        cmd = listOsTypes.listOsTypesCmd()
        cmd.description = param
        return self.apiclient.listOsTypes(cmd)[0].id

    def __verify_values(self, expected_vals, actual_vals):

        return_flag = True

        if len(expected_vals) != len(actual_vals):
            return False

        keys = list(expected_vals.keys())
        for i in range(0, len(expected_vals)):
            exp_val = expected_vals[keys[i]]
            act_val = actual_vals[keys[i]]
            if exp_val == act_val:
                return_flag = return_flag and True
            else:
                return_flag = return_flag and False
                self.debug(
                    "expected Value: %s, is not matching with actual value:\
                    %s" %
                    (exp_val, act_val))
        return return_flag

    def validate_uploaded_template(self, apiclient, template_id, retries=70, interval=5):
        """Check if template download will finish in 1 minute"""
        while retries > -1:
            time.sleep(interval)
            template_response = Template.list(
                apiclient,
                id=template_id,
                zoneid=self.zone.id,
                templatefilter='self'
            )

            if isinstance(template_response, list):
                template = template_response[0]
                if not hasattr(template, 'status') or not template or not template.status:
                    retries = retries - 1
                    continue

                # If template is ready,
                # template.status = Download Complete
                # Downloading - x% Downloaded
                # if Failed
                # Error - Any other string
                if 'Failed' in template.status:
                    raise Exception(
                        "Failed to download template: status - %s" %
                        template.status)

                elif template.status == 'Download Complete' and template.isready:
                    return

                elif 'Downloaded' in template.status:
                    retries = retries - 1
                    continue

                elif 'Installing' not in template.status:
                    if retries >= 0:
                        retries = retries - 1
                        continue
                    raise Exception(
                        "Error in downloading template: status - %s" %
                        template.status)

            else:
                retries = retries - 1
        raise Exception("Template download failed exception.")

    def gettemplatelimts(self):

        totalresourcelist=Account.list(
                                      self.apiclient,
                                      id=self.account.id
                                      )
        totaltemplates=totalresourcelist[0].templatetotal

        return(totaltemplates)

    def getstoragelimits(self, rtype):

        cmd=updateResourceCount.updateResourceCountCmd()
        cmd.account=self.account.name
        cmd.domainid=self.domain.id
        cmd.resourcetype=rtype

        response=self.apiclient.updateResourceCount(cmd)

        totalstorage=response[0].resourcecount

        return(totalstorage)

    def browse_upload_template(self):
        cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
        cmd.zoneid = self.test_template.zoneid
        cmd.format = self.test_template.format
        cmd.name=self.test_template.name + self.account.name + (random.choice(string.ascii_uppercase))
        cmd.account=self.account.name
        cmd.domainid=self.domain.id
        cmd.displaytext=self.test_template.name + self.account.name + (random.choice(string.ascii_uppercase))
        cmd.hypervisor=self.test_template.hypervisor
        cmd.ostypeid=self.test_template.ostypeid
        #cmd.isdynamicallyscalable="false"
        #cmd.type="template"
        getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)

        signt=getuploadparamsresponse.signature
        posturl=getuploadparamsresponse.postURL
        metadata=getuploadparamsresponse.metadata
        expiredata=getuploadparamsresponse.expires
        #url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
        url=self.test_template.url

        uploadfile = url.split('/')[-1]
        r = requests.get(url, stream=True)
        with open(uploadfile, 'wb') as f:
            for chunk in r.iter_content(chunk_size=1024):
                if chunk: # filter out keep-alive new chunks
                    f.write(chunk)
                    f.flush()

        #uploadfile='rajani-thin-volume.vhd'

        #files={'file':('rajani-thin-volume.vhd',open(uploadfile,'rb'),'application/octet-stream')}

        #headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}

        files={'file':(uploadfile,open(uploadfile,'rb'),'application/octet-stream')}

        headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}

        results = requests.post(posturl,files=files,headers=headers,verify=False)

        print(results.status_code)
        if results.status_code !=200:
            self.fail("Upload is not fine")

        self.validate_uploaded_template(self.apiclient, getuploadparamsresponse.id)

        return(getuploadparamsresponse)

    def browse_upload_template_with_out_zoneid(self):

        cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
        cmd.format = self.test_template.format
        cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
        cmd.account=self.account.name
        cmd.domainid=self.domain.id
        cmd.displaytext=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
        cmd.hypervisor=self.test_template.hypervisor
        cmd.ostypeid=self.test_template.ostypeid

        success= False
        try:
            getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)
        except Exception as ex:
            if "Invalid Parameter" in str(ex):
                success = True
        self.assertEqual(
                success,
                True,
                "Upload Template - verify upload Template API request is handled without mandatory params - zoneid ")

        return

    def browse_upload_template_with_out_ostypeid(self):


        cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
        cmd.zoneid = self.zone.id
        cmd.format = self.test_template.format
        cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
        cmd.account=self.account.name
        cmd.domainid=self.domain.id
        cmd.displaytext=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
        cmd.hypervisor=self.test_template.hypervisor

        success= False
        try:
            getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)
        except Exception as ex:
            if "Invalid Parameter" in str(ex):
                success = True
        self.assertEqual(
                success,
                True,
                "Upload Template - verify upload template API request is handled without mandatory params - ostypeid")

        return

    def browse_upload_template_with_projectid(self,projectid):
        cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
        cmd.zoneid = self.zone.id
        cmd.format = self.test_template.format
        cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
        cmd.account=self.account.name
        cmd.domainid=self.domain.id
        cmd.displaytext=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
        cmd.hypervisor=self.test_template.hypervisor
        cmd.ostypeid=self.test_template.ostypeid
        cmd.projectid=projectid
        #cmd.isdynamicallyscalable="false"
        #cmd.type="template"
        getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)

        signt=getuploadparamsresponse.signature
        posturl=getuploadparamsresponse.postURL
        metadata=getuploadparamsresponse.metadata
        expiredata=getuploadparamsresponse.expires
        #url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
        url=self.test_template.url

        uploadfile = url.split('/')[-1]
        r = requests.get(url, stream=True)
        with open(uploadfile, 'wb') as f:
            for chunk in r.iter_content(chunk_size=1024):
                if chunk: # filter out keep-alive new chunks
                    f.write(chunk)
                    f.flush()

        files={'file':(uploadfile,open(uploadfile,'rb'),'application/octet-stream')}

        headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}

        results = requests.post(posturl,files=files,headers=headers,verify=False)

        print(results.status_code)
        if results.status_code !=200:
            self.fail("Upload is not fine")

        self.validate_uploaded_template(self.apiclient, getuploadparamsresponse.id)

        return(getuploadparamsresponse)

    def browse_upload_template_multiplezones(self,lzones):

        cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
        cmd.zoneid ="-1"
        cmd.format = self.test_template.format
        cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
        cmd.account=self.account.name
        cmd.domainid=self.domain.id
        cmd.displaytext=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
        cmd.hypervisor=self.test_template.hypervisor
        cmd.ostypeid=self.test_template.ostypeid
        #cmd.isdynamicallyscalable="false"
        #cmd.type="template"
        getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)

        signt=getuploadparamsresponse.signature
        posturl=getuploadparamsresponse.postURL
        metadata=getuploadparamsresponse.metadata
        expiredata=getuploadparamsresponse.expires
        #url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
        url=self.test_template.url

        uploadfile = url.split('/')[-1]
        r = requests.get(url, stream=True)
        with open(uploadfile, 'wb') as f:
            for chunk in r.iter_content(chunk_size=1024):
                if chunk: # filter out keep-alive new chunks
                    f.write(chunk)
                    f.flush()

        #uploadfile='rajani-thin-volume.vhd'

        #files={'file':('rajani-thin-volume.vhd',open(uploadfile,'rb'),'application/octet-stream')}

        #headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}

        files={'file':(uploadfile,open(uploadfile,'rb'),'application/octet-stream')}

        headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}

        results = requests.post(posturl,files=files,headers=headers,verify=False)

        print(results.status_code)
        if results.status_code !=200:
            self.fail("Upload is not fine")

        for z1 in lzones:
            self.validate_uploaded_template(self.apiclient, getuploadparamsresponse.id)

        return(getuploadparamsresponse)

    def uploadtemplate(self):
        cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
        cmd.zoneid = self.zone.id
        cmd.format = self.test_template.format
        cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
        cmd.account=self.account.name
        cmd.domainid=self.domain.id
        cmd.displaytext=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
        cmd.hypervisor=self.test_template.hypervisor
        cmd.ostypeid=self.test_template.ostypeid
        #cmd.type="template"
        getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)

        signt=getuploadparamsresponse.signature
        posturl=getuploadparamsresponse.postURL
        metadata=getuploadparamsresponse.metadata
        expiredata=getuploadparamsresponse.expires
        #url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
        url=self.test_template.url

        uploadfile = url.split('/')[-1]
        r = requests.get(url, stream=True)
        with open(uploadfile, 'wb') as f:
            for chunk in r.iter_content(chunk_size=1024):
                if chunk: # filter out keep-alive new chunks
                    f.write(chunk)
                    f.flush()

        #uploadfile='rajani-thin-volume.vhd'

        #files={'file':('rajani-thin-volume.vhd',open(uploadfile,'rb'),'application/octet-stream')}

        #headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}

        files={'file':(uploadfile,open(uploadfile,'rb'),'application/octet-stream')}

        headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}

        results = requests.post(posturl,files=files,headers=headers,verify=False)
        time.sleep(60)

        print(results.status_code)
        if results.status_code !=200:
            self.fail("Upload is not fine")

        return(getuploadparamsresponse)

    def multiple_browse_upload_template(self):

        templ1=self.uploadtemplate()
        templ2=self.uploadtemplate()
        templ3=self.uploadtemplate()

        self.validate_uploaded_template(self.apiclient, templ1.id)
        self.validate_uploaded_template(self.apiclient, templ2.id)
        self.validate_uploaded_template(self.apiclient, templ3.id)

        self.delete_template(templ1)
        self.delete_template(templ2)
        self.delete_template(templ3)
        return

    def validate_vm(self, apiclient, vm_id, state, retries=72, interval=5):

        """Check if vm  will be running in 6 minute"""
        while retries > -1:
            time.sleep(interval)
            vm_response = list_virtual_machines(
                apiclient,
                id=vm_id
            )

            if isinstance(vm_response, list):
                vm = vm_response[0]
                if not hasattr(vm, 'state'):
                    retries = retries - 1
                    continue

                # If vm is Running for x number of retries
                if vm.state == state:
                    return

                else:
                    retries = retries - 1
                    continue

            else:
                retries = retries - 1
        raise Exception("VM failed exception.")

    def deploy_vm(self,template):
            virtual_machine = VirtualMachine.create(
                                                    self.apiclient,
                                                    self.testdata["virtual_machine"],
                                                    templateid=template.id,
                                                    zoneid=self.zone.id,
                                                    accountid=self.account.name,
                                                    domainid=self.account.domainid,
                                                    serviceofferingid=self.service_offering.id,
                                                )
            self.validate_vm(self.apiclient, vm_id = virtual_machine.id, state="Running")
            return(virtual_machine)

    def attach_volume(self,vmlist,volid):

        list_volume_response = Volume.list(
                    self.apiclient,
                    id=volid
                )
        print(list_volume_response[0])
        vmlist.attach_volume(
                    self.apiclient,
                    list_volume_response[0]
                )
        list_volume_response = Volume.list(
                self.apiclient,
                virtualmachineid=vmlist.id,
                type='DATADISK',
                listall=True
            )
        self.assertNotEqual(
                list_volume_response,
                None,
                "Check if volume exists in ListVolumes")
        self.assertEqual(
                isinstance(list_volume_response, list),
                True,
                "Check list volumes response for valid list")
        self.validate_uploaded_volume(volid,'Ready')

    def validate_uploaded_volume(self, volid, status):
        list_volume_response = Volume.list(
                    self.apiclient,
                    id=volid,
                    listall=True
                    )

        self.assertNotEqual(
                    list_volume_response,
                    None,
                    "Check if volume exists in ListTemplates"
                )

        self.assertEqual(
                    list_volume_response[0].status,
                    status,
                    "Check volume status in List Volumes"
                )
        return

    def reboot_vm(self,vmdetails):
        vmdetails.reboot(self.apiclient)
        self.validate_vm(self.apiclient, vm_id=vmdetails.id, state="Running")

    def stop_vm(self,vmdetails):
        vmdetails.stop(self.apiclient)
        self.validate_vm(self.apiclient, vm_id=vmdetails.id, state="Stopped")

    def start_vm(self,vmdetails):
        vmdetails.start(self.apiclient)
        self.validate_vm(self.apiclient, vm_id=vmdetails.id, state="Running")

    def vmoperations(self,vmdetails):
        self.reboot_vm(vmdetails)

        self.stop_vm(vmdetails)

        self.start_vm(vmdetails)

    def detach_volume(self,vmdetails,volid):
        """Detach a Volume attached to a VM
        """
        list_volume_response = Volume.list(
                    self.apiclient,
                    id=volid
                )
        print(list_volume_response[0])
        vmdetails.detach_volume(self.apiclient,list_volume_response[0])

        # Sleep to ensure the current state will reflected in other calls
        time.sleep(self.testdata["sleep"])

        list_volume_response = Volume.list(
            self.apiclient,
            id=volid
        )
        self.assertNotEqual(
            list_volume_response,
            None,
            "Check if volume exists in ListVolumes"
        )
        self.assertEqual(
            isinstance(list_volume_response, list),
            True,
            "Check list volumes response for valid list"
        )
        volume = list_volume_response[0]
        self.assertEqual(
            volume.virtualmachineid,
            None,
            "Check if volume state (detached) is reflected"
        )

        self.assertEqual(
            volume.vmname,
            None,
            "Check if volume state (detached) is reflected"
        )
        return

    def restore_vm(self,vmdetails):
        """Test recover Virtual Machine
        """
        cmd = restoreVirtualMachine.restoreVirtualMachineCmd()
        cmd.virtualmachineid = vmdetails.id
        self.apiclient.recoverVirtualMachine(cmd)

        list_vm_response = list_virtual_machines(
                                            self.apiclient,
                                            id=vmdetails.id
                                            )
        self.assertEqual(
                            isinstance(list_vm_response, list),
                            True,
                            "Check list response returns a valid list"
                        )

        self.assertNotEqual(
                            len(list_vm_response),
                            0,
                            "Check VM available in List Virtual Machines"
                        )

        self.assertEqual(
                            list_vm_response[0].state,
                            "Running",
                            "Check virtual machine is in Running state"
                        )

        return

    def restore_vm_fail(self,vmdetails):

        cmd = restoreVirtualMachine.restoreVirtualMachineCmd()
        cmd.virtualmachineid = vmdetails.id
        success= False
        try:
            self.apiclient.recoverVirtualMachine(cmd)
        except Exception as ex:
            if "isn't available in the zone" in str(ex):
                success = True
        self.assertEqual(
                success,
                True,
                "Restore VM with Deleted Template - Verify Restore VM is handled when template with which VM created id deleted")

        return

    def deletevolume(self,volumeid):
        """Delete a Volume attached to a VM
        """

        cmd = deleteVolume.deleteVolumeCmd()
        cmd.id = volumeid

        self.apiclient.deleteVolume(cmd)

        list_volume_response = Volume.list(
                                            self.apiclient,
                                            id=volumeid,
                                            type='DATADISK'
                                            )
        self.assertEqual(
                        list_volume_response,
                        None,
                        "Check if volume exists in ListVolumes"
                    )
        return

    def destroy_vm(self,vmdetails):

        vmdetails.delete(self.apiclient, expunge=False)

        list_vm_response = list_virtual_machines(
                                            self.apiclient,
                                            id=vmdetails.id
                                            )
        self.assertEqual(
                            isinstance(list_vm_response, list),
                            True,
                            "Check list response returns a valid list"
                        )

        self.assertNotEqual(
                            len(list_vm_response),
                            0,
                            "Check VM available in List Virtual Machines"
                        )

        self.assertEqual(
                            list_vm_response[0].state,
                            "Destroyed",
                            "Check virtual machine is in destroyed state"
                        )
        return

    def recover_destroyed_vm(self,vmdetails):

        cmd = recoverVirtualMachine.recoverVirtualMachineCmd()
        cmd.id = vmdetails.id
        self.apiclient.recoverVirtualMachine(cmd)

        list_vm_response = list_virtual_machines(
                                            self.apiclient,
                                            id=vmdetails.id
                                            )
        self.assertEqual(
                            isinstance(list_vm_response, list),
                            True,
                            "Check list response returns a valid list"
                        )

        self.assertNotEqual(
                            len(list_vm_response),
                            0,
                            "Check VM available in List Virtual Machines"
                        )

        self.assertEqual(
                            list_vm_response[0].state,
                            "Stopped",
                            "Check virtual machine is in Stopped state"
                        )

        return

    def expunge_vm(self,vmdetails):

        self.debug("Expunge VM-ID: %s" % vmdetails.id)

        cmd = destroyVirtualMachine.destroyVirtualMachineCmd()
        cmd.id = vmdetails.id
        self.apiclient.destroyVirtualMachine(cmd)

        config = Configurations.list(
                                     self.apiclient,
                                     name='expunge.delay'
                                     )

        expunge_delay = int(config[0].value)
        time.sleep(expunge_delay * 2)

        #VM should be destroyed unless expunge thread hasn't run
        #Wait for two cycles of the expunge thread
        config = Configurations.list(
                                     self.apiclient,
                                     name='expunge.interval'
                                     )
        expunge_cycle = int(config[0].value)
        wait_time = expunge_cycle * 4
        while wait_time >= 0:
            list_vm_response = list_virtual_machines(
                                                self.apiclient,
                                                id=vmdetails.id
                                                )
            if not list_vm_response:
                break
            self.debug("Waiting for VM to expunge")
            time.sleep(expunge_cycle)
            wait_time = wait_time - expunge_cycle

            self.debug("listVirtualMachines response: %s" % list_vm_response)

            self.assertEqual(list_vm_response,None,"Check Expunged virtual machine is in listVirtualMachines response")
            return

        list_vm_response = list_virtual_machines(
            self.apiclient,
            id=vmdetails.id
        )
        if isinstance(list_vm_response, list):
            self.fail("VM has not been expunged")

    def waitForSystemVMAgent(self, vmname):
        timeout = self.testdata["timeout"]

        while True:
            list_host_response = list_hosts(
                                                 self.apiclient,
                                                 name=vmname
                                                )

            if list_host_response and list_host_response[0].state == 'Up':
                break

            if timeout == 0:
                raise Exception("Timed out waiting for SSVM agent to be Up")

            time.sleep(self.testdata["sleep"])
            timeout = timeout - 1

    def ssvm_internals(self):

        list_ssvm_response = list_ssvms(
                                        self.apiclient,
                                        systemvmtype='secondarystoragevm',
                                        state='Running',
                                        zoneid=self.zone.id
                                        )
        self.assertEqual(
                            isinstance(list_ssvm_response, list),
                            True,
                            "Check list response returns a valid list"
                        )
        ssvm = list_ssvm_response[0]

        hosts = list_hosts(
                           self.apiclient,
                           id=ssvm.hostid
                           )
        self.assertEqual(
                            isinstance(hosts, list),
                            True,
                            "Check list response returns a valid list"
                        )
        host = hosts[0]

        self.debug("Running SSVM check script")

        if self.hypervisor.lower() in ('vmware', 'hyperv'):
            #SSH into SSVMs is done via management server for Vmware and Hyper-V
            result = get_process_status(
                                self.apiclient.connection.mgtSvr,
                                22,
                                self.apiclient.connection.user,
                                self.apiclient.connection.passwd,
                                ssvm.privateip,
                                "/usr/local/cloud/systemvm/ssvm-check.sh |grep -e ERROR -e WARNING -e FAIL",
                                hypervisor=self.hypervisor
                                )
        else:
            try:
                host.user, host.passwd = get_host_credentials(self.config, host.ipaddress)
                result = get_process_status(
                                    host.ipaddress,
                                    22,
                                    host.user,
                                    host.passwd,
                                    ssvm.linklocalip,
                                    "/usr/local/cloud/systemvm/ssvm-check.sh |grep -e ERROR -e WARNING -e FAIL"
                                )
            except KeyError:
                self.skipTest("Marvin configuration has no host credentials to check router services")
        res = str(result)
        self.debug("SSVM script output: %s" % res)

        self.assertEqual(
                            res.count("ERROR"),
                            1,
                            "Check for Errors in tests"
                        )

        self.assertEqual(
                            res.count("WARNING"),
                            1,
                            "Check for warnings in tests"
                        )

        #Check status of cloud service
        if self.hypervisor.lower() in ('vmware', 'hyperv'):
            #SSH into SSVMs is done via management server for Vmware and Hyper-V
            result = get_process_status(
                                self.apiclient.connection.mgtSvr,
                                22,
                                self.apiclient.connection.user,
                                self.apiclient.connection.passwd,
                                ssvm.privateip,
                                "systemctl is-active cloud",
                                hypervisor=self.hypervisor
                                )
        else:
            try:
                host.user, host.passwd = get_host_credentials(self.config, host.ipaddress)
                result = get_process_status(
                                    host.ipaddress,
                                    22,
                                    host.user,
                                    host.passwd,
                                    ssvm.linklocalip,
                                    "systemctl is-active cloud"
                                    )
            except KeyError:
                self.skipTest("Marvin configuration has no host credentials to check router services")
        res = str(result)
        self.debug("Cloud Process status: %s" % res)
        # Apache CloudStack service (type=secstorage) is running: process id: 2346
        self.assertEqual(
                            res.count("active"),
                            1,
                            "Check cloud service is running or not"
                        )
        return

    def list_sec_storage_vm(self):

        list_ssvm_response = list_ssvms(
                                        self.apiclient,
                                        systemvmtype='secondarystoragevm',
                                        state='Running',
                                        )
        self.assertEqual(
                            isinstance(list_ssvm_response, list),
                            True,
                            "Check list response returns a valid list"
                        )
        #Verify SSVM response
        self.assertNotEqual(
                            len(list_ssvm_response),
                            0,
                            "Check list System VMs response"
                        )

        list_zones_response = list_zones(self.apiclient)

        self.assertEqual(
                            isinstance(list_zones_response, list),
                            True,
                            "Check list response returns a valid list"
                        )

        self.debug("Number of zones: %s" % len(list_zones_response))
        self.debug("Number of SSVMs: %s" % len(list_ssvm_response))
        # Number of Sec storage VMs = No of Zones
        self.assertEqual(
                            len(list_ssvm_response),
                            len(list_zones_response),
                            "Check number of SSVMs with number of zones"
                        )
        #For each secondary storage VM check private IP,
        #public IP, link local IP and DNS
        for ssvm in list_ssvm_response:

            self.debug("SSVM state: %s" % ssvm.state)
            self.assertEqual(
                            ssvm.state,
                            'Running',
                            "Check whether state of SSVM is running"
                        )

            self.assertEqual(
                            hasattr(ssvm, 'privateip'),
                            True,
                            "Check whether SSVM has private IP field"
                            )

            self.assertEqual(
                            hasattr(ssvm, 'linklocalip'),
                            True,
                            "Check whether SSVM has link local IP field"
                            )

            self.assertEqual(
                            hasattr(ssvm, 'publicip'),
                            True,
                            "Check whether SSVM has public IP field"
                            )

            #Fetch corresponding ip ranges information from listVlanIpRanges
            ipranges_response = list_vlan_ipranges(
                                                   self.apiclient,
                                                   zoneid=ssvm.zoneid
                                                   )
            self.assertEqual(
                            isinstance(ipranges_response, list),
                            True,
                            "Check list response returns a valid list"
                        )
            iprange = ipranges_response[0]

            #Fetch corresponding Physical Network of SSVM's Zone
            listphyntwk = PhysicalNetwork.list(
                            self.apiclient,
                            zoneid=ssvm.zoneid
                            )

            # Execute the following assertion in all zones except EIP-ELB Zones
            if not (self.zone.networktype.lower() == 'basic' and isinstance(NetScaler.list(self.apiclient,physicalnetworkid=listphyntwk[0].id), list) is True):
                self.assertEqual(
                            ssvm.gateway,
                            iprange.gateway,
                            "Check gateway with that of corresponding ip range"
                            )

            #Fetch corresponding zone information from listZones
            zone_response = list_zones(
                                       self.apiclient,
                                       id=ssvm.zoneid
                                       )
            self.assertEqual(
                            isinstance(zone_response, list),
                            True,
                            "Check list response returns a valid list"
                        )
            self.assertEqual(
                            ssvm.dns1,
                            zone_response[0].dns1,
                            "Check DNS1 with that of corresponding zone"
                            )

            self.assertEqual(
                            ssvm.dns2,
                            zone_response[0].dns2,
                            "Check DNS2 with that of corresponding zone"
                            )
        return

    def stop_ssvm(self):

        list_ssvm_response = list_ssvms(
                                        self.apiclient,
                                        systemvmtype='secondarystoragevm',
                                        state='Running',
                                        zoneid=self.zone.id
                                        )
        self.assertEqual(
                            isinstance(list_ssvm_response, list),
                            True,
                            "Check list response returns a valid list"
                        )
        ssvm = list_ssvm_response[0]

        hosts = list_hosts(
                           self.apiclient,
                           id=ssvm.hostid
                           )
        self.assertEqual(
                            isinstance(hosts, list),
                            True,
                            "Check list response returns a valid list"
                        )
        host = hosts[0]

        self.debug("Stopping SSVM: %s" % ssvm.id)
        cmd = stopSystemVm.stopSystemVmCmd()
        cmd.id = ssvm.id
        self.apiclient.stopSystemVm(cmd)

        timeout = self.testdata["timeout"]
        while True:
            list_ssvm_response = list_ssvms(
                                        self.apiclient,
                                        id=ssvm.id
                                        )
            if isinstance(list_ssvm_response, list):
                if list_ssvm_response[0].state == 'Running':
                    break
            if timeout == 0:
                raise Exception("List SSVM call failed!")

            time.sleep(self.testdata["sleep"])
            timeout = timeout - 1

        self.assertEqual(
                            isinstance(list_ssvm_response, list),
                            True,
                            "Check list response returns a valid list"
                        )
        ssvm_response = list_ssvm_response[0]
        self.debug("SSVM state after debug: %s" % ssvm_response.state)
        self.assertEqual(
                        ssvm_response.state,
                        'Running',
                        "Check whether SSVM is running or not"
                        )
        # Wait for the agent to be up
        self.waitForSystemVMAgent(ssvm_response.name)

        # Call above tests to ensure SSVM is properly running
        self.list_sec_storage_vm()

    def reboot_ssvm(self):

        list_ssvm_response = list_ssvms(
                                        self.apiclient,
                                        systemvmtype='secondarystoragevm',
                                        state='Running',
                                        zoneid=self.zone.id
                                        )

        self.assertEqual(
                            isinstance(list_ssvm_response, list),
                            True,
                            "Check list response returns a valid list"
                        )

        ssvm_response = list_ssvm_response[0]

        hosts = list_hosts(
                           self.apiclient,
                           id=ssvm_response.hostid
                           )
        self.assertEqual(
                            isinstance(hosts, list),
                            True,
                            "Check list response returns a valid list"
                        )
        host = hosts[0]

        #Store the public & private IP values before reboot
        old_public_ip = ssvm_response.publicip
        old_private_ip = ssvm_response.privateip

        self.debug("Rebooting SSVM: %s" % ssvm_response.id)
        cmd = rebootSystemVm.rebootSystemVmCmd()
        cmd.id = ssvm_response.id
        self.apiclient.rebootSystemVm(cmd)

        timeout = self.testdata["timeout"]
        while True:
            list_ssvm_response = list_ssvms(
                                        self.apiclient,
                                        id=ssvm_response.id
                                        )
            if isinstance(list_ssvm_response, list):
                if list_ssvm_response[0].state == 'Running':
                    break
            if timeout == 0:
                raise Exception("List SSVM call failed!")

            time.sleep(self.testdata["sleep"])
            timeout = timeout - 1

        ssvm_response = list_ssvm_response[0]
        self.debug("SSVM State: %s" % ssvm_response.state)
        self.assertEqual(
                        'Running',
                        str(ssvm_response.state),
                        "Check whether CPVM is running or not"
                        )

        self.assertEqual(
                    ssvm_response.publicip,
                    old_public_ip,
                    "Check Public IP after reboot with that of before reboot"
                    )

        self.assertEqual(
                    ssvm_response.privateip,
                    old_private_ip,
                    "Check Private IP after reboot with that of before reboot"
                    )

        # Wait for the agent to be up
        self.waitForSystemVMAgent(ssvm_response.name)

        return

    def destroy_ssvm(self):

        list_ssvm_response = list_ssvms(
                                        self.apiclient,
                                        systemvmtype='secondarystoragevm',
                                        state='Running',
                                        zoneid=self.zone.id
                                        )
        self.assertEqual(
                            isinstance(list_ssvm_response, list),
                            True,
                            "Check list response returns a valid list"
                        )
        ssvm_response = list_ssvm_response[0]

        old_name = ssvm_response.name

        self.debug("Destroying SSVM: %s" % ssvm_response.id)
        cmd = destroySystemVm.destroySystemVmCmd()
        cmd.id = ssvm_response.id
        self.apiclient.destroySystemVm(cmd)

        timeout = self.testdata["timeout"]
        while True:
            list_ssvm_response = list_ssvms(
                                        self.apiclient,
                                        zoneid=self.zone.id,
                                        systemvmtype='secondarystoragevm'
                                        )
            if isinstance(list_ssvm_response, list):
                if list_ssvm_response[0].state == 'Running':
                    break
            if timeout == 0:
                raise Exception("List SSVM call failed!")

            time.sleep(self.testdata["sleep"])
            timeout = timeout - 1

        ssvm_response = list_ssvm_response[0]

        # Verify Name, Public IP, Private IP and Link local IP
        # for newly created SSVM
        self.assertNotEqual(
                        ssvm_response.name,
                        old_name,
                        "Check SSVM new name with name of destroyed SSVM"
                        )
        self.assertEqual(
                        hasattr(ssvm_response, 'privateip'),
                        True,
                        "Check whether SSVM has private IP field"
                        )

        self.assertEqual(
                        hasattr(ssvm_response, 'linklocalip'),
                        True,
                        "Check whether SSVM has link local IP field"
                        )

        self.assertEqual(
                        hasattr(ssvm_response, 'publicip'),
                        True,
                        "Check whether SSVM has public IP field"
                        )

        # Wait for the agent to be up
        self.waitForSystemVMAgent(ssvm_response.name)

        return

    def create_data_volume(self):

        diskoffering = DiskOffering.list(self.apiclient)
        self.assertTrue(
            isinstance(
                diskoffering,
                list),
            msg="DiskOffering list is not a list?")
        self.assertTrue(
            len(diskoffering) > 0,
            "no disk offerings in the deployment")

        vol = Volume.create(
            self.apiclient,
            services=self.testdata["volume"],
            zoneid=self.zone.id,
            account=self.account.name,
            domainid=self.domain.id,
            diskofferingid=diskoffering[0].id
        )
        self.assertTrue(
            vol is not None, "volume creation fails in domain %s as user %s" %
            (self.domain.name, self.account.name))

        listed_vol = Volume.list(self.apiclient, id=vol.id)
        self.assertTrue(
            listed_vol is not None and isinstance(
                listed_vol,
                list),
            "invalid response from listVolumes for volume %s" %
            vol.id)
        self.assertTrue(
            listed_vol[0].id == vol.id,
            "Volume returned by list volumes %s not matching with queried\
                    volume %s in domain %s" %
            (listed_vol[0].id,
                vol.id,
                self.account.name))
        return(listed_vol[0])

    def attach_data_volume(self,volume,vmdetails):

        list_volume_response = Volume.list(
            self.apiclient,
            id=volume.id
        )
        self.assertNotEqual(
            list_volume_response,
            None,
            "Check if volume exists in ListVolumes"
        )
        self.assertEqual(
            isinstance(list_volume_response, list),
            True,
            "Check list volumes response for valid list"
        )
        volume = list_volume_response[0]

        self.assertEqual(
            volume.type,
            'DATADISK',
            "Check volume type from list volume response"
        )

        self.assertEqual(
            hasattr(volume, 'vmname'),
            True,
            "Check whether volume has vmname field"
        )
        self.assertEqual(
            hasattr(volume, 'virtualmachineid'),
            True,
            "Check whether volume has virtualmachineid field"
        )

        # Attach volume to VM
        self.debug("Attach volume: %s to VM: %s" % (
            volume.id,
            vmdetails.id
        ))
        vmdetails.attach_volume(self.apiclient, volume)

        # Check all volumes attached to same VM
        list_volume_response = Volume.list(
            self.apiclient,
            virtualmachineid=vmdetails.id,
            type='DATADISK',
            listall=True
        )
        self.assertNotEqual(
            list_volume_response,
            None,
            "Check if volume exists in ListVolumes"
        )
        self.assertEqual(
            isinstance(list_volume_response, list),
            True,
            "Check list volumes response for valid list"
        )
        volume = list_volume_response[0]
        self.assertEqual(
            volume.vmname,
            vmdetails.name,
            "Check virtual machine name in list volumes response"
        )
        self.assertEqual(
            volume.virtualmachineid,
            vmdetails.id,
            "Check VM ID in list Volume response"
        )
        return

    def delete_template(self,templatedetails):

        list_template_response = Template.list(
                                    self.apiclient,
                                    templatefilter="all",
                                    id=templatedetails.id,
                                    zoneid=self.zone.id)

        if list_template_response is None:
            self.debug("Template is not available")
            return

        cmd = deleteTemplate.deleteTemplateCmd()
        cmd.id = templatedetails.id
        self.apiclient.deleteTemplate(cmd)

        list_template_response = Template.list(
                                    self.apiclient,
                                    templatefilter="all",
                                    id=templatedetails.id,
                                    zoneid=self.zone.id
                                    )
        self.assertEqual(
                            list_template_response,
                            None,
                            "Check template available in List Templates"
                        )
        return

    def detach_data_volume(self,volume,vmdetails):

        self.debug("Detach volume: %s to VM: %s" % (
            volume.id,
            vmdetails.id
        ))
        vmdetails.detach_volume(self.apiclient, volume)

        # Sleep to ensure the current state will reflected in other calls
        time.sleep(self.testdata["sleep"])

        list_volume_response = Volume.list(
            self.apiclient,
            id=volume.id
        )
        self.assertNotEqual(
            list_volume_response,
            None,
            "Check if volume exists in ListVolumes"
        )
        self.assertEqual(
            isinstance(list_volume_response, list),
            True,
            "Check list volumes response for valid list"
        )
        volumelist = list_volume_response[0]
        self.assertEqual(
            volumelist.virtualmachineid,
            None,
            "Check if volume state (detached) is reflected"
        )

        self.assertEqual(
            volumelist.vmname,
            None,
            "Check if volume state (detached) is reflected"
        )
        return

    # was tags = ["advanced", "advancedns", "smoke", "basic"]
    @attr(tags = ["TODO"], required_hardware="true")
    def test_01_Browser_template_Life_cycle_tpath(self):
        """
        Test Browser_template_Life_cycle
        """
        #try:

        self.debug("========================= Test 1: Upload Browser based template and validate ========================= ")
        browseup_template=self.browse_upload_template()

        self.debug("========================= Test 2: Deploy a VM with uploaded template and validate VM Operations========================= ")

        vm1details=self.deploy_vm(browseup_template)

        self.vmoperations(vm1details)

        self.debug("========================= Test 3: Attach DATA DISK to the VM ")

        cvolume=self.create_data_volume()
        self.attach_data_volume(cvolume, vm1details)
        self.vmoperations(vm1details)

        self.debug("========================= Test 4: Restore VM created with Uploaded template========================= ")

        self.restore_vm(vm1details)

        self.debug("========================= Test 5: Detach DATA DISK to the VM ")

        self.detach_data_volume(cvolume,vm1details)
        self.vmoperations(vm1details)

        self.deletevolume(cvolume.id)


        self.debug("========================= Test 6: Expunge VM created with Uploaded template========================= ")

        self.expunge_vm(vm1details)

        self.debug("========================= Test 7:  Destroy VM ========================= ")

        vm2details=self.deploy_vm(self.template)

        vm2details=self.deploy_vm(browseup_template)
        self.destroy_vm(vm2details)

        self.debug("========================= Test 8:  Recover destroyed VM which has Uploaded volumes attached========================= ")

        self.recover_destroyed_vm(vm2details)
        self.expunge_vm(vm2details)

        self.debug("========================= Test 9:  Delete the Uploaded Template========================= ")
        self.debug(browseup_template)
        self.delete_template(browseup_template)

        self.debug("========================= Test 10:  Upload Multiple templates========================= ")

        self.multiple_browse_upload_template()

#        except Exception as e:
#            self.fail("Exception occurred  : %s" % e)
        return

    # was tags = ["advanced", "advancedns", "smoke", "basic"]
    @attr(tags = ["TODO"], required_hardware="true")
    def test_02_SSVM_Life_Cycle_With_Browser_Template_TPath(self):
        """
        Test SSVM_Life_Cycle_With_Browser_template_TPath
        """
        try:

            self.debug("========================= Test 11: Stop and Start SSVM and Perform Browser based volume validations ========================= ")

            self.stop_ssvm()
            ssvm1browseup_template=self.browse_upload_template()

            ssvm1vm1details=self.deploy_vm(ssvm1browseup_template)
            #ssvm1vm1details=self.deploy_vm(self.template)

            self.vmoperations(ssvm1vm1details)

            self.expunge_vm(ssvm1vm1details)

            self.debug("========================= Test 12: Reboot SSVM and Perform Browser based volume validations ========================= ")

            self.reboot_ssvm()
            ssvm2browseup_template=self.browse_upload_template()

            ssvm2vm1details=self.deploy_vm(ssvm2browseup_template)

            #ssvm2vm1details=self.deploy_vm(self.template)
            self.vmoperations(ssvm2vm1details)

            self.expunge_vm(ssvm2vm1details)

            self.debug("========================= Test 13: Destroy SSVM and Perform Browser based volume validations ========================= ")

            self.destroy_ssvm()
            ssvm3browseup_template=self.browse_upload_template()

            ssvm3vm1details=self.deploy_vm(ssvm3browseup_template)

            #ssvm2vm1details=self.deploy_vm(self.template)
            self.vmoperations(ssvm3vm1details)

            self.expunge_vm(ssvm3vm1details)

        except Exception as e:
            self.fail("Exception occurred  : %s" % e)
        return

    @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
    def test_03_Browser_template_upload_multiple_zones(self):
        """
        Test Browser_template_upload_multiple_zones
        """

        cmd = listZones.listZonesCmd()
        zonelist=self.apiclient.listZones(cmd)
        if len(zonelist) <2:
            raise self.skipTest("Only one zone available hence skipping")
        try:

            self.debug("========================= Test 14: Upload Browser based template into multiple zones ========================= ")
            browseup_template=self.browse_upload_template_multiplezones(zonelist)

        except Exception as e:
            self.fail("Exception occurred  : %s" % e)
        return

    # was tags = ["advanced", "advancedns", "smoke", "basic"]
    @attr(tags = ["TODO"], required_hardware="true")
    def test_04_Browser_template_ResetVM_With_Deleted_Template(self):
        """
        Test Browser_template_upload_ResetVM_With_Deleted_Template
        """
        try:

            self.debug("========================= Test 15: Test Browser_template_upload_ResetVM_With_Deleted_Template ========================= ")

            browseup_template=self.browse_upload_template()

            vm1details=self.deploy_vm(browseup_template)

            self.delete_template(browseup_template)

            self.restore_vm_fail(vm1details)

        except Exception as e:
            self.fail("Exception occurred  : %s" % e)
        return

    # was tags = ["advanced", "advancedns", "smoke", "basic"]
    @attr(tags = ["TODO"], required_hardware="true")
    def test_05_Browser_Upload_Template_with_all_API_parameters(self):
        """
        Test Browser_Upload_Template with all API parameters
        """
        try:

            self.debug("========================= Test 16 & 17 Upload template with account name and domainid========================")

            browseup_template1=self.browse_upload_template()

            self.debug("========================= Test 18 Upload template with project id========================")
            browseup_template2=self.browse_upload_template_with_projectid(self.project.id)

            self.debug("========================= Test 19 Upload template with out mandatory param zone id ========================")

            browseup_vol2=self.browse_upload_template_with_out_zoneid()

            self.debug("========================= Test 20 Upload template with out mandatory param ostypeid ========================")

            browseup_vol3=self.browse_upload_template_with_out_ostypeid()

        except Exception as e:
            self.fail("Exception occurred  : %s" % e)
        return

    # was tags = ["advanced", "advancedns", "smoke", "basic"]
    @attr(tags = ["TODO"], required_hardware="true")
    def test_06_Browser_Upload_template_resource_limits(self):
        """
        Test Browser Upload Template Resource limits
        """
        try:

            self.debug("========================= Test 21 Upload Template and verify Template limits========================")
            initialtemplatelimit=self.gettemplatelimts()
            browseup_template1=self.browse_upload_template()
            # Adding time for limit to sync in background
            time.sleep(120)
            afteruploadtemplatelimit=self.gettemplatelimts()

            if int(afteruploadtemplatelimit)!=(int(initialtemplatelimit)+1):
                self.fail("Volume Resource Count is not updated")

            self.delete_template(browseup_template1)

        except Exception as e:
            self.fail("Exception occurred  : %s" % e)
        return

    # was tags = ["advanced", "advancedns", "smoke", "basic"]
    @attr(tags = ["TODO"], required_hardware="true")
    def test_07_Browser_Upload_template_secondary_storage_resource_limits(self):
        """
        Test Browser_Upload_Template Secondary Storage Resource limits
        """
        try:

            self.debug("========================= Test 22 Upload template and verify secondary storage limits========================")

            initialsecondarystoragelimit=self.getstoragelimits(11)
            browseup_template1=self.browse_upload_template()

            tmpldetails=Template.list(
                                      self.apiclient,
                                      id=browseup_template1.id,
                                     templatefilter="all",
                                     zoneid=self.zone.id)


            afteruploadsecondarystoragelimit=self.getstoragelimits(11)

            if afteruploadsecondarystoragelimit!=(initialsecondarystoragelimit+tmpldetails[0].size):
                self.fail("Secondary Storage Resource Count is not updated")

            self.delete_template(browseup_template1)

        except Exception as e:
            self.fail("Exception occurred  : %s" % e)
        return

    # was tags = ["advanced", "advancedns", "smoke", "basic"]
    @attr(tags = ["TODO"], required_hardware="true")
    def test_08_Browser_Upload_template_resource_limits_after_deletion(self):
        """
        Test Browser_Upload_Template Resource limits after template deletion
        """
        try:
            self.debug("========================= Test 23 Delete Upload template and verify template limits========================")
            browseup_template1=self.browse_upload_template()
            initialtemplatelimit=self.gettemplatelimts()

            self.delete_template(browseup_template1)
            aftertemplatelimit=self.gettemplatelimts()

            if aftertemplatelimit!=(initialtemplatelimit-1):
                self.fail("Template Resource Count is not updated after deletion")

        except Exception as e:
            self.fail("Exceptione occurred  : %s" % e)
        return

    # was tags = ["advanced", "advancedns", "smoke", "basic"]
    @attr(tags = ["TODO"], required_hardware="true")
    def test_09_Browser_Upload_Volume_secondary_storage_resource_limits_after_deletion(self):
        """
        Test Browser_Upload_Template Secondary Storage Resource limits after template deletion
        """
        try:
            self.debug("========================= Test 24 Delete Upload template and verify secondary storage limits========================")

            browseup_template1=self.browse_upload_template()

            tmpldetails=Template.list(
                                      self.apiclient,
                                      id=browseup_template1.id,
                                     templatefilter="all",
                                     zoneid=self.zone.id)

            initialuploadprimarystoragelimit=self.getstoragelimits(11)
            self.delete_template(browseup_template1)

            afteruploadprimarystoragelimit=self.getstoragelimits(11)

            if afteruploadprimarystoragelimit!=(initialuploadprimarystoragelimit-tmpldetails[0].size):
                self.fail("Secondary Storage Resource Count is not updated after deletion")

        except Exception as e:
            self.fail("Exception occurred  : %s" % e)
        return

    # @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
    @attr(tags = ["TODO"], required_hardware="false")
    def test_browser_upload_template_incomplete(self):
        """
        Test browser based incomplete template upload, followed by SSVM destroy. Template should go to UploadAbandoned state and get cleaned up.
        """
        try:
            self.debug("========================= Test browser based incomplete template upload ========================")

            #Only register template, without uploading
            cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()

            if 'kvm' in self.hypervisor.lower():
                cmd.url = 'http://dl.openvm.eu/cloudstack/centos/x86_64/centos-7-kvm.qcow2.bz2'
            if 'vmware' in self.hypervisor.lower():
                cmd.url = 'http://dl.openvm.eu/cloudstack/centos/x86_64/centos-7-vmware.ova'
            if 'xenserver' in self.hypervisor.lower():
                cmd.url = 'http://dl.openvm.eu/cloudstack/centos/x86_64/centos-7-xen.vhd.bz2'

            cmd.zoneid = self.zone.id
            cmd.format = self.test_template.format
            cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
            cmd.account=self.account.name
            cmd.domainid=self.domain.id
            cmd.displaytext=cmd.name
            cmd.hypervisor=self.test_template.hypervisor
            cmd.ostypeid=self.test_template.ostypeid
            template_response=self.apiclient.getUploadParamsForTemplate(cmd)

            #Destroy SSVM, and wait for new one to start
            self.destroy_ssvm()

            #Verify that the template is cleaned up as part of sync-up during new SSVM start
            list_template_response=Template.list(
                                        self.apiclient,
                                        id=template_response.id,
                                        templatefilter="all",
                                        zoneid=self.zone.id)
            self.assertEqual(list_template_response, None, "Template is not cleaned up, some issue with template sync-up")

        except Exception as e:
            self.fail("Exceptione occurred  : %s" % e)
        return

    @classmethod
    def tearDownClass(self):
        super(TestBrowseUploadVolume, self).tearDownClass()

    def tearDown(self):
        super(TestBrowseUploadVolume, self).tearDown()