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

from marvin.cloudstackAPI import *
from marvin.lib.utils import random_gen
from nose.plugins.attrib import attr
from marvin.cloudstackTestCase import cloudstackTestCase
from marvin.lib.utils import (cleanup_resources)
from marvin.lib.base import (Account,
                             Volume,
                             ServiceOffering,
                             DiskOffering,
                             VirtualMachine,
                             Snapshot)
from marvin.lib.common import (get_domain,
                               get_template,
                               get_zone,
                               get_pod,
                               list_snapshots,
                               list_volumes)
from marvin.lib.decoratorGenerators import skipTestIf
from marvin.codes import (
    FAILED,
    JOB_FAILED,
    JOB_CANCELLED,
    JOB_SUCCEEDED
)
import time
from marvin.codes import PASS

class TestSnapshotRootDisk(cloudstackTestCase):
    @classmethod
    def setUpClass(cls):
        testClient = super(TestSnapshotRootDisk, cls).getClsTestClient()
        cls.apiclient = testClient.getApiClient()
        cls.services = testClient.getParsedTestDataConfig()

        # Get Zone, Domain and templates
        cls.domain = get_domain(cls.apiclient)
        cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
        cls.pod = get_pod(cls.apiclient, cls.zone.id)
        cls.services['mode'] = cls.zone.networktype


        cls.hypervisorNotSupported = False
        cls.hypervisor = cls.testClient.getHypervisorInfo()
        if cls.hypervisor.lower() in ['hyperv', 'lxc'] or 'kvm-centos6' in cls.testClient.getZoneForTests():
            cls.hypervisorNotSupported = True

        cls._cleanup = []
        if not cls.hypervisorNotSupported:
            cls.template = get_template(cls.apiclient, template_type='BUILTIN')
            cls.services["domainid"] = cls.domain.id
            cls.services["small"]["zoneid"] = cls.zone.id
            cls.services["templates"]["ostypeid"] = cls.template.ostypeid
            cls.services["zoneid"] = cls.zone.id
            # Create VMs, NAT Rules etc
            cls.account = Account.create(
                cls.apiclient,
                cls.services["account"],
                domainid=cls.domain.id
            )
            cls.service_offering = ServiceOffering.create(
                cls.apiclient,
                cls.services["service_offerings"]["tiny"]
            )
            cls.disk_offering = DiskOffering.create(
                cls.apiclient,
                cls.services["disk_offering"]
            )
            cls.virtual_machine = cls.virtual_machine_with_disk = \
                VirtualMachine.create(
                    cls.apiclient,
                    cls.services["small"],
                    templateid=cls.template.id,
                    accountid=cls.account.name,
                    domainid=cls.account.domainid,
                    zoneid=cls.zone.id,
                    serviceofferingid=cls.service_offering.id,
                    mode=cls.services["mode"]
                )

            cls._cleanup.append(cls.service_offering)
            cls._cleanup.append(cls.account)
            # cls._cleanup.append(cls.template)
            cls._cleanup.append(cls.disk_offering)

        return

    @classmethod
    def tearDownClass(cls):
        try:
            # Cleanup resources used
            cleanup_resources(cls.apiclient, cls._cleanup)
        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)
        return

    def setUp(self):
        self.apiclient = self.testClient.getApiClient()
        self.dbclient = self.testClient.getDbConnection()
        self.cleanup = []
        return

    def tearDown(self):
        try:
            # Clean up, terminate the created instance, volumes and snapshots
            # cleanup_resources(self.apiclient, self.cleanup)

            for obj in self.cleanup:
                """Delete Volume"""
                cmd = deleteVolume.deleteVolumeCmd()
                cmd.id = obj.id
                self.apiclient.deleteVolume(cmd)

        except Exception as e:
            raise Exception("Warning: Exception during cleanup : %s" % e)
        return


    # Method to create volume from snapshot but will return immediately as an asynchronous task does.
    def create_from_snapshot(cls, apiclient, snapshot_id, services,
                             account=None, domainid=None):
            """Create volume from snapshot"""
            cmd = createVolume.createVolumeCmd()
            cmd.isAsync = "false"
            cmd.name = "-".join([services["diskname"], random_gen()])
            cmd.snapshotid = snapshot_id
            cmd.zoneid = services["zoneid"]
            if "size" in services:
                cmd.size = services["size"]
            if services["ispublic"]:
                cmd.ispublic = services["ispublic"]
            else:
                cmd.ispublic = False
            if account:
                cmd.account = account
            else:
                cmd.account = services["account"]
            if domainid:
                cmd.domainid = domainid
            else:
                cmd.domainid = services["domainid"]
            return Volume(apiclient.createVolume(cmd).__dict__)


    def query_async_job(self, apiclient, jobid):
        """Query the status for Async Job"""
        try:
            asyncTimeout = 5600
            cmd = queryAsyncJobResult.queryAsyncJobResultCmd()
            cmd.jobid = jobid
            timeout = asyncTimeout
            async_response = FAILED
            while timeout > 0:
                async_response = apiclient.queryAsyncJobResult(cmd)
                if async_response != FAILED:
                    job_status = async_response.jobstatus
                    if job_status in [JOB_CANCELLED,
                                      JOB_SUCCEEDED]:
                        break
                    elif job_status == JOB_FAILED:
                        raise Exception("Job failed: %s" \
                                        % async_response)
                time.sleep(5)
                timeout -= 5
                self.debug("=== JobId: %s is Still Processing, "
                           "Will TimeOut in: %s ====" % (str(jobid),
                                                         str(timeout)))
            return async_response
        except Exception as e:
            self.debug("==== Exception Occurred for Job: %s ====" %
                       str(e))
            return FAILED

    @skipTestIf("hypervisorNotSupported")
    @attr(tags=["advanced", "advancedns", "smoke"], required_hardware="true")
    def test_01_snapshot_root_disk(self):
        """Test Snapshot Root Disk
        """

        # Validate the following
        # 1. Account List should list the accounts that was existed.
        # 2. List Volumes
        # 3. Create Snapshot From the volume[0] from volume list
        # 4. List Snapshots
        # 5. Create Volume V1,V2,V3 from Snapshot List[0]
        # 6. Verify that Async Job id's status
        # 7. List all the volumes
        # 8. Add Volumes V1,V2,V3 to cleanup
        # 9. Check list response returns a valid list
        # 10. Check if result exists in list item call

        # 1. Account List should list the accounts that was existed.
        account_list = Account.list(
            self.apiclient,
            listAll = True,
            roleType ='Admin'
            );

        # 2. List Volumes
        volumes = list_volumes(
            self.apiclient,
            virtualmachineid=self.virtual_machine_with_disk.id,
            type='ROOT',
            listall=True
        )

        # 3. Create Snapshot From the volume[0] from volume list
        snapshot = Snapshot.create(
            self.apiclient,
            volumes[0].id,
            account=self.account.name,
            domainid=self.account.domainid
        )
        #self._cleanup.append(snapshot)
        self.debug("Snapshot created: ID - %s" % snapshot.id)

        # 4. List Snapshots
        snapshots = list_snapshots(
            self.apiclient,listall=True
            )

        # 5. Create Volume V1,V2,V3 from Snapshot List[0]
        services = {"diskname": "Vol", "zoneid": self.zone.id, "size": 10, "ispublic": True}
        vol1_jobId = self.create_from_snapshot(
             self.apiclient,snapshots[0].id,
            services,

            account_list[0].name,
            account_list[0].domainid
         );

        vol2_jobId = self.create_from_snapshot(
            self.apiclient, snapshots[0].id,
            services,

            account_list[0].name,
            account_list[0].domainid
        );

        vol3_jobId = self.create_from_snapshot(
             self.apiclient, snapshots[0].id,
             services,

             account_list[0].name,
             account_list[0].domainid
         );

        # 6. Verify that Async Job id's status
        self.query_async_job(self.apiclient, vol1_jobId.jobid)
        self.query_async_job(self.apiclient, vol2_jobId.jobid)
        self.query_async_job(self.apiclient, vol3_jobId.jobid)

        # 7. List all the volumes
        list_volume_response = Volume.list(
            self.apiclient,
            type="DATADISK",
            account=account_list[0].name,
            domainid=account_list[0].domainid
        )

        # 8. Add Volumes V1,V2,V3 to cleanup
        self.cleanup.append(list_volume_response[0]);
        self.cleanup.append(list_volume_response[1]);
        self.cleanup.append(list_volume_response[2]);

        # 9. Check list response returns a valid list
        self.assertEqual(
            isinstance(list_volume_response, list),
            True,
            "Check list response returns a valid list"
        )


        # 10.Check if result exists in list item call
        self.assertNotEqual(
            list_volume_response,
            None,
            "Check if result exists in list item call"
        )

        self.assertIsNotNone(snapshots[0].zoneid,
                             "Zone id is not none in listSnapshots")
        self.assertEqual(
            snapshots[0].zoneid,
            self.zone.id,
            "Check zone id in the list snapshots"
        )

        return