Return-Path: X-Original-To: apmail-cloudstack-commits-archive@www.apache.org Delivered-To: apmail-cloudstack-commits-archive@www.apache.org Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by minotaur.apache.org (Postfix) with SMTP id B283A18FF0 for ; Tue, 19 May 2015 16:21:02 +0000 (UTC) Received: (qmail 57147 invoked by uid 500); 19 May 2015 16:20:48 -0000 Delivered-To: apmail-cloudstack-commits-archive@cloudstack.apache.org Received: (qmail 57073 invoked by uid 500); 19 May 2015 16:20:48 -0000 Mailing-List: contact commits-help@cloudstack.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@cloudstack.apache.org Delivered-To: mailing list commits@cloudstack.apache.org Received: (qmail 56500 invoked by uid 99); 19 May 2015 16:20:48 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Tue, 19 May 2015 16:20:48 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id 56056E2F70; Tue, 19 May 2015 16:20:48 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: koushik@apache.org To: commits@cloudstack.apache.org Date: Tue, 19 May 2015 16:21:29 -0000 Message-Id: In-Reply-To: <2e3041e27e184d788a455323974dbd40@git.apache.org> References: <2e3041e27e184d788a455323974dbd40@git.apache.org> X-Mailer: ASF-Git Admin Mailer Subject: [43/50] [abbrv] git commit: updated refs/heads/CLOUDSTACK-8301 to 8ff9000 CLOUDSTACK-8481: Adding test cases for validating global limit on concurrent snapshots Signed-off-by: Gaurav Aradhye This closes #252 Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/19c436fd Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/19c436fd Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/19c436fd Branch: refs/heads/CLOUDSTACK-8301 Commit: 19c436fd592de6cebd347892c8225362c90b4660 Parents: 4b597ca Author: Gaurav Aradhye Authored: Tue May 19 15:15:29 2015 +0530 Committer: Gaurav Aradhye Committed: Tue May 19 15:25:29 2015 +0530 ---------------------------------------------------------------------- .../test_concurrent_snapshots_limit.py | 299 +++++++++++++++++++ 1 file changed, 299 insertions(+) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/cloudstack/blob/19c436fd/test/integration/component/test_concurrent_snapshots_limit.py ---------------------------------------------------------------------- diff --git a/test/integration/component/test_concurrent_snapshots_limit.py b/test/integration/component/test_concurrent_snapshots_limit.py new file mode 100644 index 0000000..910cb00 --- /dev/null +++ b/test/integration/component/test_concurrent_snapshots_limit.py @@ -0,0 +1,299 @@ +# 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 for validating global limit for concurrent snapshots +""" +from nose.plugins.attrib import attr +from marvin.cloudstackTestCase import cloudstackTestCase +from marvin.lib.utils import (cleanup_resources, + validateList) +from marvin.lib.base import (Account, + ServiceOffering, + VirtualMachine, + Snapshot, + Volume, + Configurations + ) +from marvin.lib.common import (get_domain, + get_zone, + get_template + ) + +from marvin.codes import PASS, BACKED_UP +from threading import Thread + + +class TestConcurrentSnapshotLimit(cloudstackTestCase): + + @classmethod + def setUpClass(cls): + testClient = super(TestConcurrentSnapshotLimit, cls).getClsTestClient() + cls.apiclient = testClient.getApiClient() + cls.testdata = testClient.getParsedTestDataConfig() + cls.hypervisor = cls.testClient.getHypervisorInfo() + + # Get Zone, Domain and templates + cls.domain = get_domain(cls.apiclient) + cls.zone = get_zone(cls.apiclient, testClient.getZoneForTests()) + + cls.template = get_template( + cls.apiclient, + cls.zone.id, + cls.testdata["ostype"]) + + cls._cleanup = [] + cls.supportedHypervisor = True + + if cls.hypervisor.lower() in [ + "hyperv", + "lxc"]: + cls.supportedHypervisor = False + return + + # Create Service offering + cls.service_offering = ServiceOffering.create( + cls.apiclient, + cls.testdata["service_offering"], + ) + cls._cleanup.append(cls.service_offering) + return + + @classmethod + def tearDownClass(cls): + try: + cleanup_resources(cls.apiclient, cls._cleanup) + except Exception as e: + raise Exception("Warning: Exception during cleanup : %s" % e) + + def setUp(self): + self.apiclient = self.testClient.getApiClient() + self.dbclient = self.testClient.getDbConnection() + self.cleanup = [] + + self.exceptionOccured = False + + if not self.supportedHypervisor: + self.skipTest("Snapshot not supported on %s" % self.hypervisor) + + def createSnapshot(self, volumeid): + try: + Snapshot.create( + self.apiclient, + volumeid + ) + except Exception as e: + self.debug("Exception occured: %s" % e) + self.exceptionOccured = True + + def tearDown(self): + try: + cleanup_resources(self.apiclient, self.cleanup) + except Exception as e: + raise Exception("Warning: Exception during cleanup : %s" % e) + return + + @attr(tags=["advanced", "basic"], required_hardware="true") + def test_01_concurrent_snapshot_global_limit(self): + """ Test if global value concurrent.snapshots.threshold.perhost + value respected + This is positive test cases and tests if we are able to create + as many snapshots mentioned in global value + # 1. Create an account and a VM in it + # 2. Read the global value for concurrent.snapshots.threshold.perhost + # 3. If the value is Null, create at least 10 concurrent snapshots + and verify they are created successfully + # 4. Else, create as many snapshots specified in the global value, and + verify they are created successfully + """ + + # Create an account + account = Account.create( + self.apiclient, + self.testdata["account"], + domainid=self.domain.id + ) + + self.cleanup.append(account) + # Create user api client of the account + userapiclient = self.testClient.getUserApiClient( + UserName=account.name, + DomainName=account.domain + ) + + # Create VM + virtual_machine = VirtualMachine.create( + userapiclient, + self.testdata["small"], + templateid=self.template.id, + accountid=account.name, + domainid=account.domainid, + serviceofferingid=self.service_offering.id, + zoneid=self.zone.id + ) + + # Create 10 concurrent snapshots by default + # We can have any value, so keeping it 10 as it + # seems good enough to test + concurrentSnapshots = 10 + + # Step 1 + # Get ROOT Volume Id + volumes = Volume.list( + self.apiclient, + virtualmachineid=virtual_machine.id, + type='ROOT', + listall=True + ) + + self.assertEqual(validateList(volumes)[0], PASS, + "Volumes list validation failed") + + root_volume = volumes[0] + + config = Configurations.list( + self.apiclient, + name="concurrent.snapshots.threshold.perhost" + ) + self.assertEqual( + isinstance( + config, + list), + True, + "concurrent.snapshots.threshold.perhost should be present\ + in global config") + if config[0].value: + concurrentSnapshots = int(config[0].value) + self.debug("concurrent Snapshots: %s" % concurrentSnapshots) + + threads = [] + for i in range(0, (concurrentSnapshots)): + thread = Thread( + target=Snapshot.create, + args=( + self.apiclient, + root_volume.id + )) + threads.append(thread) + thread.start() + for thread in threads: + thread.join() + + snapshots = Snapshot.list(self.apiclient, + volumeid=root_volume.id, + listall=True) + + self.assertEqual(validateList(snapshots)[0], PASS, + "Snapshots list validation failed") + self.assertEqual( + len(snapshots), + concurrentSnapshots, + "There should be exactly %s snapshots present" % + concurrentSnapshots) + + for snapshot in snapshots: + self.assertEqual(str(snapshot.state).lower(), BACKED_UP, + "Snapshot state should be backedUp but it is\ + %s" % snapshot.state) + return + + @attr(tags=["advanced", "basic"], required_hardware="true") + def test_02_concurrent_snapshot_global_limit(self): + """ Test if global value concurrent.snapshots.threshold.perhost + value is respected + This is negative test cases and tests no more concurrent + snapshots as specified in global value are created + # 1. Read the global value for concurrent.snapshots.threshold.perhost + # 2. If the value is Null, skip the test case + # 3. Create an account and a VM in it + # 4. Create more concurrent snapshots than specified in + global allowed limit + # 5. Verify that exception is raised while creating snapshots + """ + + config = Configurations.list( + self.apiclient, + name="concurrent.snapshots.threshold.perhost" + ) + self.assertEqual( + isinstance( + config, + list), + True, + "concurrent.snapshots.threshold.perhost should be present\ + in global config") + if config[0].value: + concurrentSnapshots = int(config[0].value) + else: + self.skipTest("Skipping tests as the config value \ + concurrent.snapshots.threshold.perhost is Null") + + # Create an account + account = Account.create( + self.apiclient, + self.testdata["account"], + domainid=self.domain.id + ) + + self.cleanup.append(account) + # Create user api client of the account + userapiclient = self.testClient.getUserApiClient( + UserName=account.name, + DomainName=account.domain + ) + + # Create VM + virtual_machine = VirtualMachine.create( + userapiclient, + self.testdata["small"], + templateid=self.template.id, + accountid=account.name, + domainid=account.domainid, + serviceofferingid=self.service_offering.id, + zoneid=self.zone.id + ) + + # Step 1 + # Get ROOT Volume Id + volumes = Volume.list( + self.apiclient, + virtualmachineid=virtual_machine.id, + type='ROOT', + listall=True + ) + + self.assertEqual(validateList(volumes)[0], PASS, + "Volumes list validation failed") + + root_volume = volumes[0] + + threads = [] + for i in range(0, (concurrentSnapshots + 1)): + thread = Thread( + target=self.createSnapshot, + args=( + self.apiclient, + root_volume.id + )) + threads.append(thread) + thread.start() + + for thread in threads: + thread.join() + + self.assertTrue(self.exceptionOccured, "Concurrent snapshots\ + more than concurrent.snapshots.threshold.perhost\ + value successfully created") + return