cloudstack-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sanju1010 <...@git.apache.org>
Subject [GitHub] cloudstack pull request: CLOUDSTACK-9289:Automation for feature de...
Date Thu, 25 Feb 2016 09:49:42 GMT
Github user sanju1010 commented on a diff in the pull request:

    https://github.com/apache/cloudstack/pull/1417#discussion_r54070462
  
    --- Diff: test/integration/component/test_deploy_vm_from_snapshot.py ---
    @@ -0,0 +1,644 @@
    +# Licensed to the Apache Software Foundation (ASF) under one
    +# or more contributor license agreements.  See the NOTICE file
    +# distributed with this work for additional information
    +# regarding copyright ownership.  The ASF licenses this file
    +# to you under the Apache License, Version 2.0 (the
    +# "License"); you may not use this file except in compliance
    +# with the License.  You may obtain a copy of the License at
    +#
    +#   http://www.apache.org/licenses/LICENSE-2.0
    +#
    +# Unless required by applicable law or agreed to in writing,
    +# software distributed under the License is distributed on an
    +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    +# KIND, either express or implied.  See the License for the
    +# specific language governing permissions and limitations
    +# under the License.
    +
    +# Import Local Modules
    +from marvin.codes import FAILED, PASS
    +from nose.plugins.attrib import attr
    +from marvin.cloudstackTestCase import cloudstackTestCase
    +from marvin.cloudstackAPI import seedTemplateFromVmSnapshot
    +from marvin.lib.utils import cleanup_resources, validateList
    +from marvin.lib.base import (Account,
    +                             DiskOffering,
    +                             ServiceOffering,
    +                             VirtualMachine,
    +                             VmSnapshot,
    +                             Volume)
    +from marvin.lib.common import (get_zone,
    +                               get_domain,
    +                               get_template)
    +import urllib
    +import tempfile
    +import os
    +import time
    +from functools import reduce
    +
    +
    +class TestDeployVm(cloudstackTestCase):
    +
    +    @classmethod
    +    def setUpClass(cls):
    +        testClient = super(TestDeployVm, cls).getClsTestClient()
    +        cls.apiclient = testClient.getApiClient()
    +        cls._cleanup = []
    +        cls.unsupportedHypervisor = False
    +        cls.hypervisor = testClient.getHypervisorInfo()
    +        if not cls.hypervisor.lower() in "vmware":
    +            cls.unsupportedHypervisor = True
    +            return
    +
    +        cls.services = testClient.getParsedTestDataConfig()
    +        # Get Zone, Domain and templates
    +        cls.domain = get_domain(cls.apiclient)
    +        cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests())
    +
    +        template = get_template(
    +            cls.apiclient,
    +            cls.zone.id,
    +            cls.services["ostype"]
    +        )
    +        if template == FAILED:
    +            assert False, "get_template() failed to return template\
    +                    with description %s" % cls.services["ostype"]
    +
    +        cls.services["domainid"] = cls.domain.id
    +        cls.services["small"]["zoneid"] = cls.zone.id
    +        cls.services["templates"]["ostypeid"] = 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._cleanup.append(cls.account)
    +
    +        cls.service_offering = ServiceOffering.create(
    +            cls.apiclient,
    +            cls.services["service_offerings"]["tiny"]
    +        )
    +
    +        cls.service_offering1 = ServiceOffering.create(
    +            cls.apiclient,
    +            cls.services["service_offerings"]["small"]
    +        )
    +        cls.disk_offering = DiskOffering.create(cls.apiclient,
    +                                                cls.services["disk_offering"])
    +        cls._cleanup.append(cls.service_offering)
    +        cls._cleanup.append(cls.service_offering1)
    +        cls._cleanup.append(cls.disk_offering)
    +        cls.virtual_machine = VirtualMachine.create(
    +            cls.apiclient,
    +            cls.services["small"],
    +            templateid=template.id,
    +            accountid=cls.account.name,
    +            domainid=cls.account.domainid,
    +            serviceofferingid=cls.service_offering.id,
    +            mode=cls.zone.networktype
    +        )
    +
    +        cls.vm_snp = VmSnapshot.create(cls.apiclient,
    +                                       vmid=cls.virtual_machine.id,
    +                                       )
    +
    +        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 = []
    +
    +        if self.unsupportedHypervisor:
    +            self.skipTest("Skipping test because unsupported hypervisor\
    +                    %s" % self.hypervisor)
    +        return
    +
    +    def tearDown(self):
    +        try:
    +            # Clean up, terminate the created instance, volumes and snapshots
    +            cleanup_resources(self.apiclient, self.cleanup)
    +        except Exception as e:
    +            raise Exception("Warning: Exception during cleanup : %s" % e)
    +        return
    +
    +    @attr(tags=["basic", "advanced", "advancedns", "smoke"],
    +          required_hardware="true")
    +    def test_01_create_vm_from_vmsnapshots(self):
    +        """Test to create VM from vm snapshots without data disk
    +        1-deploy a vm from snapshot
    +        2-os type of new vm should be same as parent vm
    +        3-destroy vm
    +        4-check  volume usage
    +        5-check vm usage
    +        """
    +        vm1_from_snp = VirtualMachine.create(
    +            self.apiclient,
    +            self.services["small"],
    +            vmsnapshotid=self.vm_snp.id,
    +            accountid=self.account.name,
    +            domainid=self.account.domainid,
    +            serviceofferingid=self.service_offering1.id,
    +            mode=self.zone.networktype
    +        )
    +
    +        self.assertEqual(vm1_from_snp.ostypeid,
    +                         self.virtual_machine.ostypeid,
    +                         "check the os type for vm deployed from vm snapshot")
    +        self.assertEqual(vm1_from_snp.serviceofferingid,
    +                         self.service_offering1.id,
    +                         "check the service offering id for "
    +                         "vm deployed from vm snapshot")
    +        vm1_from_snp.delete(self.apiclient)
    +
    +        vm_id = self.dbclient.execute(
    +            "select * from vm_instance where uuid = '%s';"
    +            % vm1_from_snp.id
    +        )
    +        vol_id = self.dbclient.execute(
    +            "select * from volumes where instance_id = '%s';"
    +            % vm_id[0][0]
    +        )
    +        vol_usage = self.dbclient.execute(
    +            "select * from usage_event where resource_id= '%s' "
    +            "and resource_name= '%s';"
    +            % (vol_id[0][0], vol_id[0][7])
    +        )
    +        self.assertEqual(len(vol_usage),
    +                         3,
    +                         "check number of  volume usage")
    +        self.assertEqual(vol_usage[0][1],
    +                         "VOLUME.CREATE",
    +                         "Check for VOLUME.CREATE usage event"
    +                         )
    +        self.assertEqual(vol_usage[1][1],
    +                         "VOLUME.DELETE",
    +                         "Check for VOLUME.DELETE usage event"
    +                         )
    +        self.assertEqual(vol_usage[2][1],
    +                         "VOLUME.DELETE",
    +                         "check for VOLUME.DELETE usage event")
    +
    +    @attr(tags=["basic", "advanced", "advancedns", "smoke"],
    +          required_hardware="true")
    +    def test_02_create_vm_from_vmsnapshots_and_verify_data(self):
    +        """
    +        deploy vm from snapshot , ssh and verify data
    +        1-ssh to vm and create file
    +        2-take vm snapshot
    +        3-repeat step 1-2 for three time
    +        4-deploy vm from vm snapshot created in step 1-2
    +        5-ssh to vm and add some data
    +        """
    +        result = {}
    +        vm_snp = {}
    +        for i in xrange(3):
    +            try:
    +                ssh = self.virtual_machine.get_ssh_client()
    +                ssh.execute('touch f%s' % i)
    +                ssh.execute('echo "this is file f%s">>f%s' % (i, i))
    +                result[i] = ssh.execute('cat f%s' % i)
    +
    +            except Exception as e:
    +                self.fail("SSH access failed for VM %s - %s" %
    +                          (self.virtual_machine.ipaddress, e))
    +            time.sleep(60)
    +            vm_snp[i] = VmSnapshot.create(self.apiclient,
    +                                          vmid=self.virtual_machine.id
    +                                          )
    +
    +            ssh.execute('rm -rf f%s' % i)
    +
    +        vm_from_snp_0 = VirtualMachine.create(
    --- End diff --
    
    Can you please use looping technique and avoid redundant code?


---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastructure@apache.org or file a JIRA ticket
with INFRA.
---

Mime
View raw message