You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cloudstack.apache.org by sa...@apache.org on 2015/04/20 13:59:34 UTC

[1/6] git commit: updated refs/heads/master to 4df55f1

Repository: cloudstack
Updated Branches:
  refs/heads/master 21ab28044 -> 4df55f199


Interop API Validation


Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/9d0cc122
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/9d0cc122
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/9d0cc122

Branch: refs/heads/master
Commit: 9d0cc1227233927ea8f5115b634c3246736d4dc8
Parents: 770297e
Author: sailajamada <sa...@citrix.com>
Authored: Fri Apr 17 17:23:52 2015 +0530
Committer: sailajamada <sa...@citrix.com>
Committed: Fri Apr 17 17:23:52 2015 +0530

----------------------------------------------------------------------
 .../component/test_interop_xd_ccp.py            | 1131 ++++++++++++++++++
 1 file changed, 1131 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cloudstack/blob/9d0cc122/test/integration/component/test_interop_xd_ccp.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_interop_xd_ccp.py b/test/integration/component/test_interop_xd_ccp.py
new file mode 100644
index 0000000..dda946d
--- /dev/null
+++ b/test/integration/component/test_interop_xd_ccp.py
@@ -0,0 +1,1131 @@
+# 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.
+""" BVT tests for XenDesktop CloudPlatform InterOperability
+"""
+#Import Local Modules
+from marvin.cloudstackTestCase import cloudstackTestCase
+from marvin.cloudstackAPI import (restoreVirtualMachine,
+                                  destroyVirtualMachine,
+                                  listVirtualMachines,
+                                  attachIso,
+                                  detachIso,
+                                  listHypervisorCapabilities,
+                                  deleteVolume,
+                                  createVolume,
+                                  attachVolume)
+from marvin.lib.utils import (cleanup_resources,
+                              validateList)
+from marvin.lib.base import (SecurityGroup,
+                             NetworkOffering,
+                             Account,
+                             Template,
+                             ServiceOffering,
+                             VirtualMachine,
+                             Host,
+                             Configurations,
+                             Volume,
+                             DiskOffering,
+                             Domain,
+                             StoragePool,
+                             Region,
+                             Zone,
+                             Network)
+from marvin.lib.common import (get_domain,
+                                get_zone,
+                                get_template,
+                                get_pod,
+                                list_hosts,
+                                get_windows_template
+                                )
+
+from marvin.codes import FAILED, PASS
+from nose.plugins.attrib import attr
+#Import System modules
+import time
+
+_multiprocess_shared_ = True
+class TestXDCCPInterop(cloudstackTestCase):
+
+    @classmethod
+    def setUpClass(cls):
+        testClient = super(TestXDCCPInterop, 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.services['mode'] = cls.zone.networktype
+
+        hosts = list_hosts(
+               cls.apiclient,
+               type="Routing"
+           )
+   
+        if hosts is None:
+               raise unittest.SkipTest(
+                   "There are no hypervisor's available.Check list hosts response")
+        for hypervisorhost in hosts :
+                    if hypervisorhost.hypervisor == "XenServer":
+                        cls.uploadtemplateformat="VHD"
+                        break
+                    elif hypervisorhost.hypervisor== "VMware":
+                        cls.uploadtemplateformat="OVA"
+                        break
+                    elif hypervisorhost.hypervisor== "KVM":
+                       cls.uploadtemplateformat="KVM"
+                    break
+
+        if cls.uploadtemplateformat=="KVM":
+            assert False, "Interop is not supported on KVM"
+
+        cls.uploadurl=cls.services["interop"][cls.uploadtemplateformat]["url"]
+  
+        cls.xtemplate = get_template(
+            cls.apiclient,
+            cls.zone.id,
+            cls.services["ostype"]
+        )
+        if cls.xtemplate == FAILED:
+            assert False, "get_template() failed to return template with description %s" % cls.services["ostype"]
+
+        cls.account = Account.create(
+            cls.apiclient,
+            cls.services["account"],
+            domainid=cls.domain.id
+        )
+        cls.debug(cls.account.id)
+
+        cls.service_offering = ServiceOffering.create(
+            cls.apiclient,
+            cls.services["service_offerings"]["large"]
+        )
+
+        cls.template = get_windows_template(
+            cls.apiclient,
+            cls.zone.id,
+            ostype_desc="Windows 8 (64-bit)")
+        #cls.template = get_windows_template(cls.apiclient, cls.zone.id ,ostype_desc="Windows Server 2012 (64-bit)")
+
+        if cls.template == FAILED:
+            if "http://pleaseupdateURL/" in cls.uploadurl:
+                raise unittest.SkipTest(
+                    "Check Test Data file if it has the valid template URL")
+            cls.template = Template.register(
+                cls.apiclient,
+                cls.services["interop"][cls.uploadtemplateformat],
+                zoneid=cls.zone.id,
+                domainid=cls.account.domainid,
+                account=cls.account.name,
+                isdynamicallyscalable="true"
+            )
+            timeout = cls.services["vgpu"]["timeout"]
+
+            while True:
+                time.sleep(cls.services["vgpu"]["sleep"]) 
+                list_template_response = Template.list(
+                    cls.apiclient,
+                    templatefilter=cls.services["templatefilter"],
+                    id=cls.template.id
+                )
+                if (isinstance(list_template_response, list)) is not True:
+                    raise unittest.SkipTest(
+                        "Check list template api response returns a valid list")
+
+                if len(list_template_response) is None:
+                    raise unittest.SkipTest(
+                        "Check template registered is in List Templates")
+
+                template_response = list_template_response[0]
+                if template_response.isready:
+                    break
+
+                if timeout == 0:
+                    raise unittest.SkipTest(
+                        "Failed to download template(ID: %s). " %
+                        template_response.id)
+
+                timeout = timeout - 1
+        cls.volume=[]
+
+        # Set Zones and disk offerings
+        cls.services["small"]["zoneid"] = cls.zone.id
+        cls.services["small"]["template"] = cls.template.id
+
+        cls.services["medium"]["zoneid"] = cls.zone.id
+        cls.services["medium"]["template"] = cls.template.id
+
+#        cls.services["large"]["zoneid"] = cls.zone.id
+#        cls.services["large"]["template"] = cls.template.id
+        """
+        cls.virtual_machine = VirtualMachine.create(
+            cls.apiclient,
+            cls.services["medium"],
+            accountid=cls.account.name,
+            domainid=cls.account.domainid,
+            serviceofferingid=cls.service_offering.id,  
+            mode=cls.services['mode'],
+            startvm="false"
+        )
+        """
+        cls.cleanup = [
+            cls.service_offering,
+            cls.account
+        ]
+
+    @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 = []
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_01_create_list_delete_security_group(self):
+        """
+        Test Security Group Creation,List,Deletion on a Basic
+        """
+        if self.zone.networktype!="Basic":
+            self.skipTest("Security Group creation is applicable only with Basic zone setup. skipping")
+
+        sg=SecurityGroup.create(self.apiclient,
+                                self.services("security_group")
+                                )
+
+        listsg=SecurityGroup.list(self.apiclient,id=sg.id)
+
+        if sg.name!=listsg[0].name:
+            self.fail("Security Group is not created with specified details")
+
+        sg.delete(self.apiclient)
+
+        return
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_01_list_all_regions_with_noparams(self):
+        """
+        Test List Regions With No Parameters
+        """
+        regionavailable="no"
+        listregions=Region.list(self.apiclient)
+
+        self.assertEqual(
+                            isinstance(listregions, list),
+                            True,
+                            "Check listRegions response returns a valid list"
+                        )
+
+        for reg1 in listregions:
+            if reg1.name=="Local":
+                regionavailable="yes"
+                exit
+        if regionavailable=="no":
+            self.fail("There is no region created")
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_02_list_all_diskofferings_with_noparams(self):
+        """
+        Test List Disk Offerings with No Parameters
+        """
+
+        diskofferingvailable=0
+        listdiskofferings=DiskOffering.list(self.apiclient)
+
+        self.assertEqual(
+                            isinstance(listdiskofferings, list),
+                            True,
+                            "Check list Disk Offerings response returns a valid list"
+                        )
+
+        for diskoffering1 in listdiskofferings:
+            if diskoffering1.name=="Small":
+                diskofferingvailable=diskofferingvailable+1
+            elif diskoffering1.name=="Medium":
+                diskofferingvailable=diskofferingvailable+1
+            elif diskoffering1.name=="Large":
+                diskofferingvailable=diskofferingvailable+1
+            elif diskoffering1.name=="Custom":
+                diskofferingvailable=diskofferingvailable+1
+
+        if diskofferingvailable<4:
+            self.fail("All the default disk offerings are not listed")
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_03_list_all_Serviceofferings_with_noparams(self):
+        """
+        Test List Service Offerings with No Parameters
+        """
+
+        serviceofferingvailable=0
+        listserviceofferings=ServiceOffering.list(self.apiclient)
+
+        self.assertEqual(
+                            isinstance(listserviceofferings, list),
+                            True,
+                            "Check list Service Offerings response returns a valid list"
+                        )
+
+        for serviceoffering1 in listserviceofferings:
+            if serviceoffering1.name=="Small Instance":
+                serviceofferingvailable=serviceofferingvailable+1
+            elif serviceoffering1.name=="Medium Instance":
+                serviceofferingvailable=serviceofferingvailable+1
+
+        if serviceofferingvailable<2:
+            self.fail("All the default service offerings are not listed")
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
+    def test_04_list_zones_with_no_params(self):
+
+        """
+        Test list zones
+        """
+        zonesavailable=0
+        listallzones=Zone.list(self.apiclient)
+
+        self.assertEqual(
+                            isinstance(listallzones, list),
+                            True,
+                            "Check list zones response returns a valid list"
+                        )
+
+        for zone1 in listallzones:
+            if zone1.allocationstate=="Enabled":
+                zonesavailable=zonesavailable+1
+ 
+        if zonesavailable<1:
+            self.fail("Check if zones are listed")
+
+        return
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_05_validate_stopped_vm_deployment(self):
+        """
+        Test Deploy Virtual Machine in Stopped State
+        """
+
+        list_vm_response = VirtualMachine.list(
+                                                 self.apiclient,
+                                                 id=self.virtual_machine.id
+                                                 )
+
+        self.debug(
+                "Verify listVirtualMachines response for virtual machine: %s" \
+                % self.virtual_machine.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"
+                        )
+        vm_response = list_vm_response[0]
+        self.assertEqual(
+
+                            vm_response.id,
+                            self.virtual_machine.id,
+                            "Check virtual machine id in listVirtualMachines"
+                        )
+        self.assertEqual(
+                    vm_response.name,
+                    self.virtual_machine.name,
+                    "Check virtual machine name in listVirtualMachines"
+                    )
+        self.assertEqual(
+            vm_response.state,
+            'Stopped',
+             msg="VM is not in Stopped state"
+        )
+        return
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_06_attachvolume_to_a_stopped_vm(self):
+        """
+        Test Attach Volume To A Stopped VM
+        """
+
+        list_vm_response = VirtualMachine.list(
+                                                 self.apiclient,
+                                                 id=self.virtual_machine.id
+                                                 )
+
+        self.assertEqual(
+            list_vm_response[0].state,
+            'Stopped',
+             msg="Check if VM is in Stopped state"
+        )
+        custom_disk_offering=DiskOffering.list(
+                                self.apiclient,
+                                 name="custom"
+                                 )
+
+        self.__class__.volume = Volume.create(
+            self.apiclient,
+            self.services["volume"],
+            zoneid=self.zone.id,
+            account=self.account.name,
+            domainid=self.account.domainid,
+            diskofferingid=custom_disk_offering[0].id,
+            size=1
+        )
+
+                # Check List Volume response for newly created volume
+        list_volume_response = Volume.list(
+                    self.apiclient,
+                    id=self.volume.id
+                )
+        self.assertNotEqual(
+                    list_volume_response,
+                    None,
+                    "Check if volume exists in ListVolumes"
+                )
+
+                # Attach volume to VM
+        cmd = attachVolume.attachVolumeCmd()
+        cmd.id = self.volume.id
+        cmd.virtualmachineid = self.virtual_machine.id
+        cmd.deviceid=1
+        vol1=self.apiclient.attachVolume(cmd)
+
+            # Check all volumes attached to same VM
+        list_volume_response = Volume.list(
+                self.apiclient,
+                virtualmachineid=self.virtual_machine.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.assertEqual(
+                list_volume_response[0].deviceid,
+                1,
+                "Check listed volume device id is 1")
+
+        return
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_07_start_vm(self):
+        """
+        Test Start Stopped Virtual Machine with volumes attached 
+        """
+
+        list_vm_response = VirtualMachine.list(
+                                                 self.apiclient,
+                                                 id=self.virtual_machine.id
+                                                 )
+
+        self.assertEqual(
+            list_vm_response[0].state,
+            'Stopped',
+             msg="Check if VM is in Stopped state before starting it"
+        )
+        self.virtual_machine.start(self.apiclient)
+
+        time.sleep(600)
+
+        list_vm_response = VirtualMachine.list(
+                                            self.apiclient,
+                                            id=self.virtual_machine.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.debug(
+                "Verify listVirtualMachines response for virtual machine: %s" \
+                % self.virtual_machine.id
+                )
+        self.assertEqual(
+                            list_vm_response[0].state,
+                            "Running",
+                            "Check virtual machine is in running state"
+                        )
+        return
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_08_list_all_vms_with_zone_id(self):
+        """
+        Test list all vm's available with the zone id
+        """
+
+        vm_available=0
+        
+        cmd = listVirtualMachines.listVirtualMachinesCmd()
+        cmd.listall = True
+        cmd.zoneid=self.zone.id
+
+        list_vm_response=self.apiclient.listVirtualMachines(cmd)
+        """
+        list_vm_response = VirtualMachine.list(
+                                                 self.apiclient,
+                                                 zoneid=self.zone.id
+                                                 )
+        """
+        self.assertEqual(
+                            isinstance(list_vm_response, list),
+                            True,
+                            "Check list vm's with zone id response returns a valid list"
+                        )
+        for vm1 in list_vm_response:
+            if vm1.id==self.virtual_machine.id:
+                vm_available=vm_available+1
+
+        if vm_available<1:
+            self.fail("List VM's with zone id is not listing the expected vm details correctly")
+
+        return
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
+    def test_09_reboot_vm(self):
+        """Test Reboot Virtual Machine
+        """
+
+        self.virtual_machine.reboot(self.apiclient)
+
+        list_vm_response = VirtualMachine.list(
+                                            self.apiclient,
+                                            id=self.virtual_machine.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
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_10_detach_volume(self):
+        """
+        Test Detach Volume 
+        """
+
+        list_volume_response1 = Volume.list(
+            self.apiclient,
+            id=self.volume.id
+        )
+
+        if  list_volume_response1[0].virtualmachineid is None:
+            self.skipTest("Check if volume is attached to the VM before detach")
+
+        self.virtual_machine.detach_volume(self.apiclient, self.volume)
+
+        # Sleep to ensure the current state will reflected in other calls
+        time.sleep(self.services["sleep"])
+
+        list_volume_response = Volume.list(
+            self.apiclient,
+            id=self.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"
+        )
+        volume1 = list_volume_response[0]
+        self.assertEqual(
+            volume1.virtualmachineid,
+            None,
+            "Check if volume state (detached) is reflected"
+        )
+
+        self.assertEqual(
+            volume1.vmname,
+            None,
+            "Check if volume state (detached) is reflected"
+        )
+        return
+
+    @attr(tags=["advanced", "advancedns"], required_hardware="false")
+    def test_11_delete_detached_volume(self):
+        """
+        Delete a Volume unattached to an VM
+        """
+
+        list_volume_response1 = Volume.list(
+            self.apiclient,
+            id=self.volume.id
+        )
+
+        if  list_volume_response1[0].virtualmachineid is not None:
+            self.skipTest("Check if volume is detached before deleting")
+
+        cmd = deleteVolume.deleteVolumeCmd()
+        cmd.id = self.volume.id
+        self.apiclient.deleteVolume(cmd)
+
+        # Sleep to ensure the current state will reflected in other calls
+        time.sleep(self.services["sleep"])
+
+        list_volume_response = Volume.list(
+            self.apiclient,
+            id=self.volume.id,
+        )
+        self.assertEqual(
+            list_volume_response,
+            None,
+            "Volume %s was not deleted" % self.volume.id
+        )
+        return
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_12_stop_vm_with_force_false(self):
+        """
+        Test Stop Virtual Machine
+        """
+
+        list_vm_response = VirtualMachine.list(
+                                                 self.apiclient,
+                                                 id=self.virtual_machine.id
+                                                 )
+
+        if list_vm_response[0].state!='Running':
+            self.skipTest("Check if VM is in Running state before stopping it")
+
+        try:
+            self.virtual_machine.stop(self.apiclient,forced="false")
+        except Exception as e:
+            self.fail("Failed to stop VM: %s" % e)
+        return
+
+
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    def test_13_destroy_vm(self):
+        """
+        Test destroy Virtual Machine
+        """
+
+        self.virtual_machine.delete(self.apiclient, expunge=False)
+
+        list_vm_response = VirtualMachine.list(
+                                            self.apiclient,
+                                            id=self.virtual_machine.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
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
+    def test_14_restore_stopped_vm(self):
+
+        """
+        Test Restoring Stopped Virtual Machine
+        """
+
+        noffering=NetworkOffering.list(
+                     self.apiclient,
+                     name="DefaultIsolatedNetworkOfferingWithSourceNatService"
+                     )
+        vmnetwork=Network.create(
+                                 self.apiclient,
+                                self.services["network"],
+                                accountid=self.account.name,
+                                domainid=self.account.domainid,
+                                networkofferingid=noffering[0].id,
+                                zoneid=self.zone.id
+                                 )
+
+        list_nw_response = Network.list(
+                                            self.apiclient,
+                                            id=vmnetwork.id
+                                            )
+        self.assertEqual(
+                            isinstance(list_nw_response, list),
+                            True,
+                            "Check list response returns a valid networks list"
+                        )
+        restorevm = VirtualMachine.create(
+            self.apiclient,
+            self.services["medium"],
+            accountid=self.account.name,
+            domainid=self.account.domainid,
+            serviceofferingid=self.service_offering.id,
+            mode=self.services['mode'],
+            networkids=list_nw_response[0].id,
+            startvm="false"
+        )
+
+
+        list_vm_response = VirtualMachine.list(
+                                            self.apiclient,
+                                            id=restorevm.id
+                                            )
+        self.assertEqual(
+                            list_vm_response[0].state,
+                            "Stopped",
+                            "Check virtual machine is in Stopped state"
+                        )
+
+        custom_disk_offering=DiskOffering.list(
+                                self.apiclient,
+                                 name="custom"
+                                 )
+
+        newvolume = Volume.create(
+            self.apiclient,
+            self.services["volume"],
+            zoneid=self.zone.id,
+            account=self.account.name,
+            domainid=self.domain.id,
+            diskofferingid=custom_disk_offering[0].id,
+            size=1
+        )
+
+                # Attach volume to VM
+        cmd = attachVolume.attachVolumeCmd()
+        cmd.id = newvolume.id
+        cmd.virtualmachineid = restorevm.id
+        cmd.deviceid=1
+        vol1=self.apiclient.attachVolume(cmd)
+
+        cmd = restoreVirtualMachine.restoreVirtualMachineCmd()
+        cmd.virtualmachineid=restorevm.id
+        self.apiclient.restoreVirtualMachine(cmd)
+
+        time.sleep(600)
+
+        list_vm_response = VirtualMachine.list(
+                                            self.apiclient,
+                                            id=restorevm.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"
+                        )
+
+        restorevm.start(self.apiclient)
+
+        list_vm_response = VirtualMachine.list(
+                                            self.apiclient,
+                                            id=restorevm.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"
+                        )
+
+        restorevm.delete(self.apiclient)
+
+        vmnetwork.delete(self.apiclient)
+
+        return
+
+
+
+    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
+    def test_15_restore_vm_with_template_id(self):
+
+        """
+        Test restoring Virtual Machine with template id
+        """
+
+        noffering=NetworkOffering.list(
+                     self.apiclient,
+                     name="DefaultIsolatedNetworkOfferingWithSourceNatService"
+                     )
+        vm1network=Network.create(
+                                 self.apiclient,
+                                self.services["network"],
+                                accountid=self.account.name,
+                                domainid=self.account.domainid,
+                                networkofferingid=noffering[0].id,
+                                zoneid=self.zone.id
+                                 )
+
+        list_nw_response = Network.list(
+                                            self.apiclient,
+                                            id=vm1network.id
+                                            )
+        self.assertEqual(
+                            isinstance(list_nw_response, list),
+                            True,
+                            "Check list response returns a valid networks list"
+                        )
+
+        restorevm = VirtualMachine.create(
+            self.apiclient,
+            self.services["medium"],
+            networkids=vm1network.id,
+            accountid=self.account.name,
+            domainid=self.account.domainid,
+            serviceofferingid=self.service_offering.id,
+            mode=self.services['mode'],
+            startvm="true"
+        )
+
+
+        time.sleep(600)
+
+        list_vm_response = VirtualMachine.list(
+                                            self.apiclient,
+                                            id=restorevm.id
+                                            )
+        self.assertEqual(
+                            list_vm_response[0].state,
+                            "Running",
+                            "Check virtual machine is in running state"
+                        )
+
+
+        custom_disk_offering=DiskOffering.list(
+                                self.apiclient,
+                                 name="custom"
+                                 )
+
+        newvolume = Volume.create(
+            self.apiclient,
+            self.services["volume"],
+            zoneid=self.zone.id,
+            account=self.account.name,
+            domainid=self.domain.id,
+            diskofferingid=custom_disk_offering[0].id,
+            size=1
+        )
+
+                # Attach volume to VM
+        cmd = attachVolume.attachVolumeCmd()
+        cmd.id = newvolume.id
+        cmd.virtualmachineid = restorevm.id
+        cmd.deviceid=1
+        vol1=self.apiclient.attachVolume(cmd)
+
+        cmd = restoreVirtualMachine.restoreVirtualMachineCmd()
+        cmd.virtualmachineid = restorevm.id
+        cmd.templateid = self.xtemplate.id
+        self.apiclient.restoreVirtualMachine(cmd)
+
+        time.sleep(600)
+
+        list_vm_response = VirtualMachine.list(
+                                            self.apiclient,
+                                            id=restorevm.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 Stopped state"
+                        )
+
+        restorevm.delete(self.apiclient)
+
+        vm1network.delete(self.apiclient)
+
+        return
+
+
+
+    @attr(tags=["advanced", "advancedns"], required_hardware="false")
+    def test_16_create_template_volume(self):
+        """Test Create template from volume
+        """
+
+        noffering=NetworkOffering.list(
+                     self.apiclient,
+                     name="DefaultIsolatedNetworkOfferingWithSourceNatService"
+                     )
+        vm2network=Network.create(
+                                 self.apiclient,
+                                self.services["network"],
+                                accountid=self.account.name,
+                                domainid=self.account.domainid,
+                                networkofferingid=noffering[0].id,
+                                zoneid=self.zone.id
+                                 )
+
+        list_nw_response = Network.list(
+                                            self.apiclient,
+                                            id=vm2network.id
+                                            )
+        self.assertEqual(
+                            isinstance(list_nw_response, list),
+                            True,
+                            "Check list response returns a valid networks list"
+                        )
+
+        templatevm = VirtualMachine.create(
+                                    self.apiclient,
+                                    self.services["medium"],
+                                    templateid=self.template.id,
+                                    accountid=self.account.name,
+                                    domainid=self.account.domainid,
+                                    networkids=vm2network.id,
+                                    serviceofferingid=self.service_offering.id,
+                                    mode=self.services['mode'],
+                                    startvm="true"
+                                    )
+        time.sleep(600)
+        vm_response = VirtualMachine.list(
+                            self.apiclient,
+                            id=templatevm.id)
+
+        self.assertNotEqual(
+                            len(vm_response),
+                            0,
+                            "Check VMs available in List VMs response"
+                        )
+        vm = vm_response[0]
+        self.assertEqual(
+                            vm.state,
+                            'Running',
+                            "Check the state of VM created from Template"
+                        )
+
+        templatevm.stop(self.apiclient,forced="false")
+
+        vm_response = VirtualMachine.list(
+                            self.apiclient,
+                            id=templatevm.id)
+
+        vm = vm_response[0]
+        self.assertEqual(
+                            vm.state,
+                            'Stopped',
+                            "Check the state of VM is in Stopped state before creating the Template"
+                        )
+
+        list_volume_response = Volume.list(
+            self.apiclient,
+            virtualmachineid=vm.id,
+            type="ROOT",
+            listall=True
+        )
+
+        #Create template from Virtual machine and Volume ID
+        roottemplate = Template.create(
+                                self.apiclient,
+                                self.services["interop"]["template"],
+                                volumeid=list_volume_response[0].id,
+                                account=self.account.name,
+                                domainid=self.domain.id,
+                                )
+
+        time.sleep(600)
+
+        list_template_response = Template.list(
+                                    self.apiclient,
+                                    templatefilter=\
+                                    self.services["templatefilter"],
+                                    id=roottemplate.id
+                                    )
+
+        self.assertEqual(
+                            isinstance(list_template_response, list),
+                            True,
+                            "Check list response returns a valid list"
+                        )
+        #Verify template response to check whether template added successfully
+        self.assertNotEqual(
+                            len(list_template_response),
+                            0,
+                            "Check template available in List Templates"
+                        )
+        template_response = list_template_response[0]
+
+        self.assertEqual(
+                            template_response.displaytext,
+                            self.services["template"]["displaytext"],
+                            "Check display text of newly created template"
+                        )
+        name = template_response.name
+        self.assertEqual(
+                            name.count(self.services["template"]["name"]),
+                            1,
+                            "Check name of newly created template"
+                        )
+        self.assertEqual(
+                            template_response.ostypeid,
+                            self.services["template"]["ostypeid"],
+                            "Check osTypeID of newly created template"
+                        )
+
+
+        templatevm.delete(self.apiclient)
+        vm2network.delete(self.apiclient)
+
+        vm3network=Network.create(
+                                 self.apiclient,
+                                self.services["network"],
+                                accountid=self.account.name,
+                                domainid=self.account.domainid,
+                                networkofferingid=noffering.id,
+                                zoneid=self.zone.id
+                                 )
+
+        list_nw_response = Network.list(
+                                            self.apiclient,
+                                            id=vm3network.id
+                                            )
+        self.assertEqual(
+                            isinstance(list_nw_response, list),
+                            True,
+                            "Check list response returns a valid networks list"
+                        )
+
+
+        templatevm = VirtualMachine.create(
+                                    self.apiclient,
+                                    self.services["medium"],
+                                    templateid=roottemplate.id,
+                                    networkids=vm3network.id,
+                                    serviceofferingid=self.service_offering.id,
+                                    accountid=self.account.name,
+                                    domainid=self.account.domainid,
+                                    mode=self.services['mode'],
+                                    startvm="true"
+                                    )
+        time.sleep(600)
+        vm_response = VirtualMachine.list(
+                            self.apiclient,
+                            id=templatevm.id)
+
+        self.assertNotEqual(
+                            len(vm_response),
+                            0,
+                            "Check VMs available in List VMs response"
+                        )
+        vm = vm_response[0]
+        self.assertEqual(
+                            vm.state,
+                            'Running',
+                            "Check the state of VM created from Template"
+                        )
+
+        # Delete the template
+        roottemplate.delete(self.apiclient)
+
+        list_template_response = Template.list(
+                                    self.apiclient,
+                                    templatefilter=\
+                                    self.services["template"]["templatefilter"],
+                                    id=roottemplate.id,
+                                    zoneid=self.zone.id
+                                    )
+        self.assertEqual(
+                            list_template_response,
+                            None,
+                            "Check template available in List Templates"
+                        )
+
+        templatevm.delete(self.apiclient)
+
+        vm3network.delete(self.apiclient)
+        return


[3/6] git commit: updated refs/heads/master to 4df55f1

Posted by sa...@apache.org.
Interop API Additional scenarios


Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/d08d60b2
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/d08d60b2
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/d08d60b2

Branch: refs/heads/master
Commit: d08d60b2f3652ef12b0609ef102c5e0caa8ca245
Parents: 6db212d
Author: sailajamada <sa...@citrix.com>
Authored: Mon Apr 20 15:22:31 2015 +0530
Committer: sailajamada <sa...@citrix.com>
Committed: Mon Apr 20 15:22:31 2015 +0530

----------------------------------------------------------------------
 .../component/test_interop_xd_ccp.py            | 409 ++++++++++++++-----
 1 file changed, 307 insertions(+), 102 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cloudstack/blob/d08d60b2/test/integration/component/test_interop_xd_ccp.py
----------------------------------------------------------------------
diff --git a/test/integration/component/test_interop_xd_ccp.py b/test/integration/component/test_interop_xd_ccp.py
index dda946d..0ef5d6e 100644
--- a/test/integration/component/test_interop_xd_ccp.py
+++ b/test/integration/component/test_interop_xd_ccp.py
@@ -56,6 +56,8 @@ from marvin.codes import FAILED, PASS
 from nose.plugins.attrib import attr
 #Import System modules
 import time
+import random
+import string
 
 _multiprocess_shared_ = True
 class TestXDCCPInterop(cloudstackTestCase):
@@ -65,7 +67,7 @@ class TestXDCCPInterop(cloudstackTestCase):
         testClient = super(TestXDCCPInterop, cls).getClsTestClient()
         cls.apiclient = testClient.getApiClient()
         cls.services = 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())
@@ -106,7 +108,8 @@ class TestXDCCPInterop(cloudstackTestCase):
         cls.account = Account.create(
             cls.apiclient,
             cls.services["account"],
-            domainid=cls.domain.id
+            domainid=cls.domain.id,
+            admin=False
         )
         cls.debug(cls.account.id)
 
@@ -130,8 +133,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                 cls.services["interop"][cls.uploadtemplateformat],
                 zoneid=cls.zone.id,
                 domainid=cls.account.domainid,
-                account=cls.account.name,
-                isdynamicallyscalable="true"
+                account=cls.account.name
             )
             timeout = cls.services["vgpu"]["timeout"]
 
@@ -169,9 +171,13 @@ class TestXDCCPInterop(cloudstackTestCase):
         cls.services["medium"]["zoneid"] = cls.zone.id
         cls.services["medium"]["template"] = cls.template.id
 
+        user_data = ''.join(random.choice(string.ascii_uppercase + string.digits) for x in range(2500))
+        cls.services["virtual_machine"]["userdata"] = user_data
+
+
 #        cls.services["large"]["zoneid"] = cls.zone.id
 #        cls.services["large"]["template"] = cls.template.id
-        """
+
         cls.virtual_machine = VirtualMachine.create(
             cls.apiclient,
             cls.services["medium"],
@@ -181,7 +187,12 @@ class TestXDCCPInterop(cloudstackTestCase):
             mode=cls.services['mode'],
             startvm="false"
         )
-        """
+        cls.user_api_client = cls.testClient.getUserApiClient(
+            UserName=cls.account.name,
+            DomainName=cls.account.domain
+        )
+
+
         cls.cleanup = [
             cls.service_offering,
             cls.account
@@ -195,12 +206,12 @@ class TestXDCCPInterop(cloudstackTestCase):
             raise Exception("Warning: Exception during cleanup : %s" % e)
 
     def setUp(self):
-        #self.apiclient = self.testClient.getApiClient()
+        #self.user_api_client = self.testClient.getApiClient()
         #self.dbclient = self.testClient.getDbConnection()
         self.cleanup = []
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns", "basic", "sg"], required_hardware="true")
     def test_01_create_list_delete_security_group(self):
         """
         Test Security Group Creation,List,Deletion on a Basic
@@ -208,26 +219,26 @@ class TestXDCCPInterop(cloudstackTestCase):
         if self.zone.networktype!="Basic":
             self.skipTest("Security Group creation is applicable only with Basic zone setup. skipping")
 
-        sg=SecurityGroup.create(self.apiclient,
+        sg=SecurityGroup.create(self.user_api_client,
                                 self.services("security_group")
                                 )
 
-        listsg=SecurityGroup.list(self.apiclient,id=sg.id)
+        listsg=SecurityGroup.list(self.user_api_client,id=sg.id)
 
         if sg.name!=listsg[0].name:
             self.fail("Security Group is not created with specified details")
 
-        sg.delete(self.apiclient)
+        sg.delete(self.user_api_client)
 
         return
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="true")
     def test_01_list_all_regions_with_noparams(self):
         """
         Test List Regions With No Parameters
         """
         regionavailable="no"
-        listregions=Region.list(self.apiclient)
+        listregions=Region.list(self.user_api_client)
 
         self.assertEqual(
                             isinstance(listregions, list),
@@ -242,14 +253,14 @@ class TestXDCCPInterop(cloudstackTestCase):
         if regionavailable=="no":
             self.fail("There is no region created")
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="true")
     def test_02_list_all_diskofferings_with_noparams(self):
         """
         Test List Disk Offerings with No Parameters
         """
 
         diskofferingvailable=0
-        listdiskofferings=DiskOffering.list(self.apiclient)
+        listdiskofferings=DiskOffering.list(self.user_api_client)
 
         self.assertEqual(
                             isinstance(listdiskofferings, list),
@@ -271,14 +282,14 @@ class TestXDCCPInterop(cloudstackTestCase):
             self.fail("All the default disk offerings are not listed")
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="true")
     def test_03_list_all_Serviceofferings_with_noparams(self):
         """
         Test List Service Offerings with No Parameters
         """
 
         serviceofferingvailable=0
-        listserviceofferings=ServiceOffering.list(self.apiclient)
+        listserviceofferings=ServiceOffering.list(self.user_api_client)
 
         self.assertEqual(
                             isinstance(listserviceofferings, list),
@@ -296,14 +307,14 @@ class TestXDCCPInterop(cloudstackTestCase):
             self.fail("All the default service offerings are not listed")
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="false")
     def test_04_list_zones_with_no_params(self):
 
         """
         Test list zones
         """
         zonesavailable=0
-        listallzones=Zone.list(self.apiclient)
+        listallzones=Zone.list(self.user_api_client)
 
         self.assertEqual(
                             isinstance(listallzones, list),
@@ -321,14 +332,14 @@ class TestXDCCPInterop(cloudstackTestCase):
         return
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="true")
     def test_05_validate_stopped_vm_deployment(self):
         """
         Test Deploy Virtual Machine in Stopped State
         """
 
         list_vm_response = VirtualMachine.list(
-                                                 self.apiclient,
+                                                 self.user_api_client,
                                                  id=self.virtual_machine.id
                                                  )
 
@@ -365,14 +376,14 @@ class TestXDCCPInterop(cloudstackTestCase):
         )
         return
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="true")
     def test_06_attachvolume_to_a_stopped_vm(self):
         """
         Test Attach Volume To A Stopped VM
         """
 
         list_vm_response = VirtualMachine.list(
-                                                 self.apiclient,
+                                                 self.user_api_client,
                                                  id=self.virtual_machine.id
                                                  )
 
@@ -382,12 +393,12 @@ class TestXDCCPInterop(cloudstackTestCase):
              msg="Check if VM is in Stopped state"
         )
         custom_disk_offering=DiskOffering.list(
-                                self.apiclient,
+                                self.user_api_client,
                                  name="custom"
                                  )
 
         self.__class__.volume = Volume.create(
-            self.apiclient,
+            self.user_api_client,
             self.services["volume"],
             zoneid=self.zone.id,
             account=self.account.name,
@@ -398,7 +409,7 @@ class TestXDCCPInterop(cloudstackTestCase):
 
                 # Check List Volume response for newly created volume
         list_volume_response = Volume.list(
-                    self.apiclient,
+                    self.user_api_client,
                     id=self.volume.id
                 )
         self.assertNotEqual(
@@ -412,11 +423,11 @@ class TestXDCCPInterop(cloudstackTestCase):
         cmd.id = self.volume.id
         cmd.virtualmachineid = self.virtual_machine.id
         cmd.deviceid=1
-        vol1=self.apiclient.attachVolume(cmd)
+        vol1=self.user_api_client.attachVolume(cmd)
 
             # Check all volumes attached to same VM
         list_volume_response = Volume.list(
-                self.apiclient,
+                self.user_api_client,
                 virtualmachineid=self.virtual_machine.id,
                 type='DATADISK',
                 listall=True
@@ -437,14 +448,14 @@ class TestXDCCPInterop(cloudstackTestCase):
 
         return
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="true")
     def test_07_start_vm(self):
         """
         Test Start Stopped Virtual Machine with volumes attached 
         """
 
         list_vm_response = VirtualMachine.list(
-                                                 self.apiclient,
+                                                 self.user_api_client,
                                                  id=self.virtual_machine.id
                                                  )
 
@@ -453,12 +464,12 @@ class TestXDCCPInterop(cloudstackTestCase):
             'Stopped',
              msg="Check if VM is in Stopped state before starting it"
         )
-        self.virtual_machine.start(self.apiclient)
+        self.virtual_machine.start(self.user_api_client)
 
         time.sleep(600)
 
         list_vm_response = VirtualMachine.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=self.virtual_machine.id
                                             )
         self.assertEqual(
@@ -485,7 +496,7 @@ class TestXDCCPInterop(cloudstackTestCase):
         return
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="true")
     def test_08_list_all_vms_with_zone_id(self):
         """
         Test list all vm's available with the zone id
@@ -497,10 +508,10 @@ class TestXDCCPInterop(cloudstackTestCase):
         cmd.listall = True
         cmd.zoneid=self.zone.id
 
-        list_vm_response=self.apiclient.listVirtualMachines(cmd)
+        list_vm_response=self.user_api_client.listVirtualMachines(cmd)
         """
         list_vm_response = VirtualMachine.list(
-                                                 self.apiclient,
+                                                 self.user_api_client,
                                                  zoneid=self.zone.id
                                                  )
         """
@@ -519,15 +530,15 @@ class TestXDCCPInterop(cloudstackTestCase):
         return
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="false")
     def test_09_reboot_vm(self):
         """Test Reboot Virtual Machine
         """
 
-        self.virtual_machine.reboot(self.apiclient)
+        self.virtual_machine.reboot(self.user_api_client)
 
         list_vm_response = VirtualMachine.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=self.virtual_machine.id
                                             )
         self.assertEqual(
@@ -550,27 +561,27 @@ class TestXDCCPInterop(cloudstackTestCase):
         return
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="true")
     def test_10_detach_volume(self):
         """
         Test Detach Volume 
         """
 
         list_volume_response1 = Volume.list(
-            self.apiclient,
+            self.user_api_client,
             id=self.volume.id
         )
 
         if  list_volume_response1[0].virtualmachineid is None:
             self.skipTest("Check if volume is attached to the VM before detach")
 
-        self.virtual_machine.detach_volume(self.apiclient, self.volume)
+        self.virtual_machine.detach_volume(self.user_api_client, self.volume)
 
         # Sleep to ensure the current state will reflected in other calls
         time.sleep(self.services["sleep"])
 
         list_volume_response = Volume.list(
-            self.apiclient,
+            self.user_api_client,
             id=self.volume.id
         )
         self.assertNotEqual(
@@ -604,7 +615,7 @@ class TestXDCCPInterop(cloudstackTestCase):
         """
 
         list_volume_response1 = Volume.list(
-            self.apiclient,
+            self.user_api_client,
             id=self.volume.id
         )
 
@@ -613,13 +624,13 @@ class TestXDCCPInterop(cloudstackTestCase):
 
         cmd = deleteVolume.deleteVolumeCmd()
         cmd.id = self.volume.id
-        self.apiclient.deleteVolume(cmd)
+        self.user_api_client.deleteVolume(cmd)
 
         # Sleep to ensure the current state will reflected in other calls
         time.sleep(self.services["sleep"])
 
         list_volume_response = Volume.list(
-            self.apiclient,
+            self.user_api_client,
             id=self.volume.id,
         )
         self.assertEqual(
@@ -630,14 +641,14 @@ class TestXDCCPInterop(cloudstackTestCase):
         return
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="true")
     def test_12_stop_vm_with_force_false(self):
         """
         Test Stop Virtual Machine
         """
 
         list_vm_response = VirtualMachine.list(
-                                                 self.apiclient,
+                                                 self.user_api_client,
                                                  id=self.virtual_machine.id
                                                  )
 
@@ -645,7 +656,7 @@ class TestXDCCPInterop(cloudstackTestCase):
             self.skipTest("Check if VM is in Running state before stopping it")
 
         try:
-            self.virtual_machine.stop(self.apiclient,forced="false")
+            self.virtual_machine.stop(self.user_api_client,forced="false")
         except Exception as e:
             self.fail("Failed to stop VM: %s" % e)
         return
@@ -653,16 +664,16 @@ class TestXDCCPInterop(cloudstackTestCase):
 
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="true")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="true")
     def test_13_destroy_vm(self):
         """
         Test destroy Virtual Machine
         """
 
-        self.virtual_machine.delete(self.apiclient, expunge=False)
+        self.virtual_machine.delete(self.user_api_client, expunge=False)
 
         list_vm_response = VirtualMachine.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=self.virtual_machine.id
                                             )
         self.assertEqual(
@@ -685,7 +696,7 @@ class TestXDCCPInterop(cloudstackTestCase):
         return
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="false")
     def test_14_restore_stopped_vm(self):
 
         """
@@ -693,11 +704,11 @@ class TestXDCCPInterop(cloudstackTestCase):
         """
 
         noffering=NetworkOffering.list(
-                     self.apiclient,
+                     self.user_api_client,
                      name="DefaultIsolatedNetworkOfferingWithSourceNatService"
                      )
         vmnetwork=Network.create(
-                                 self.apiclient,
+                                 self.user_api_client,
                                 self.services["network"],
                                 accountid=self.account.name,
                                 domainid=self.account.domainid,
@@ -706,7 +717,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                                  )
 
         list_nw_response = Network.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=vmnetwork.id
                                             )
         self.assertEqual(
@@ -715,7 +726,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                             "Check list response returns a valid networks list"
                         )
         restorevm = VirtualMachine.create(
-            self.apiclient,
+            self.user_api_client,
             self.services["medium"],
             accountid=self.account.name,
             domainid=self.account.domainid,
@@ -727,7 +738,7 @@ class TestXDCCPInterop(cloudstackTestCase):
 
 
         list_vm_response = VirtualMachine.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=restorevm.id
                                             )
         self.assertEqual(
@@ -742,7 +753,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                                  )
 
         newvolume = Volume.create(
-            self.apiclient,
+            self.user_api_client,
             self.services["volume"],
             zoneid=self.zone.id,
             account=self.account.name,
@@ -756,16 +767,16 @@ class TestXDCCPInterop(cloudstackTestCase):
         cmd.id = newvolume.id
         cmd.virtualmachineid = restorevm.id
         cmd.deviceid=1
-        vol1=self.apiclient.attachVolume(cmd)
+        vol1=self.user_api_client.attachVolume(cmd)
 
         cmd = restoreVirtualMachine.restoreVirtualMachineCmd()
         cmd.virtualmachineid=restorevm.id
-        self.apiclient.restoreVirtualMachine(cmd)
+        self.user_api_client.restoreVirtualMachine(cmd)
 
         time.sleep(600)
 
         list_vm_response = VirtualMachine.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=restorevm.id
                                             )
         self.assertEqual(
@@ -786,10 +797,10 @@ class TestXDCCPInterop(cloudstackTestCase):
                             "Check virtual machine is in Stopped state"
                         )
 
-        restorevm.start(self.apiclient)
+        restorevm.start(self.user_api_client)
 
         list_vm_response = VirtualMachine.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=restorevm.id
                                             )
         self.assertEqual(
@@ -813,13 +824,13 @@ class TestXDCCPInterop(cloudstackTestCase):
 
         restorevm.delete(self.apiclient)
 
-        vmnetwork.delete(self.apiclient)
+        vmnetwork.delete(self.user_api_client)
 
         return
 
 
 
-    @attr(tags = ["devcloud", "advanced", "advancedns", "smoke", "basic", "sg"], required_hardware="false")
+    @attr(tags = ["devcloud", "advanced", "advancedns",  "basic", "sg"], required_hardware="false")
     def test_15_restore_vm_with_template_id(self):
 
         """
@@ -827,11 +838,11 @@ class TestXDCCPInterop(cloudstackTestCase):
         """
 
         noffering=NetworkOffering.list(
-                     self.apiclient,
+                     self.user_api_client,
                      name="DefaultIsolatedNetworkOfferingWithSourceNatService"
                      )
         vm1network=Network.create(
-                                 self.apiclient,
+                                 self.user_api_client,
                                 self.services["network"],
                                 accountid=self.account.name,
                                 domainid=self.account.domainid,
@@ -840,7 +851,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                                  )
 
         list_nw_response = Network.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=vm1network.id
                                             )
         self.assertEqual(
@@ -850,7 +861,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                         )
 
         restorevm = VirtualMachine.create(
-            self.apiclient,
+            self.user_api_client,
             self.services["medium"],
             networkids=vm1network.id,
             accountid=self.account.name,
@@ -864,7 +875,7 @@ class TestXDCCPInterop(cloudstackTestCase):
         time.sleep(600)
 
         list_vm_response = VirtualMachine.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=restorevm.id
                                             )
         self.assertEqual(
@@ -875,12 +886,12 @@ class TestXDCCPInterop(cloudstackTestCase):
 
 
         custom_disk_offering=DiskOffering.list(
-                                self.apiclient,
+                                self.user_api_client,
                                  name="custom"
                                  )
 
         newvolume = Volume.create(
-            self.apiclient,
+            self.user_api_client,
             self.services["volume"],
             zoneid=self.zone.id,
             account=self.account.name,
@@ -894,17 +905,17 @@ class TestXDCCPInterop(cloudstackTestCase):
         cmd.id = newvolume.id
         cmd.virtualmachineid = restorevm.id
         cmd.deviceid=1
-        vol1=self.apiclient.attachVolume(cmd)
+        vol1=self.user_api_client.attachVolume(cmd)
 
         cmd = restoreVirtualMachine.restoreVirtualMachineCmd()
         cmd.virtualmachineid = restorevm.id
         cmd.templateid = self.xtemplate.id
-        self.apiclient.restoreVirtualMachine(cmd)
+        self.user_api_client.restoreVirtualMachine(cmd)
 
         time.sleep(600)
 
         list_vm_response = VirtualMachine.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=restorevm.id
                                             )
         self.assertEqual(
@@ -927,7 +938,7 @@ class TestXDCCPInterop(cloudstackTestCase):
 
         restorevm.delete(self.apiclient)
 
-        vm1network.delete(self.apiclient)
+        vm1network.delete(self.user_api_client)
 
         return
 
@@ -939,11 +950,11 @@ class TestXDCCPInterop(cloudstackTestCase):
         """
 
         noffering=NetworkOffering.list(
-                     self.apiclient,
+                     self.user_api_client,
                      name="DefaultIsolatedNetworkOfferingWithSourceNatService"
                      )
         vm2network=Network.create(
-                                 self.apiclient,
+                                 self.user_api_client,
                                 self.services["network"],
                                 accountid=self.account.name,
                                 domainid=self.account.domainid,
@@ -952,7 +963,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                                  )
 
         list_nw_response = Network.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=vm2network.id
                                             )
         self.assertEqual(
@@ -962,7 +973,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                         )
 
         templatevm = VirtualMachine.create(
-                                    self.apiclient,
+                                    self.user_api_client,
                                     self.services["medium"],
                                     templateid=self.template.id,
                                     accountid=self.account.name,
@@ -974,7 +985,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                                     )
         time.sleep(600)
         vm_response = VirtualMachine.list(
-                            self.apiclient,
+                            self.user_api_client,
                             id=templatevm.id)
 
         self.assertNotEqual(
@@ -989,10 +1000,10 @@ class TestXDCCPInterop(cloudstackTestCase):
                             "Check the state of VM created from Template"
                         )
 
-        templatevm.stop(self.apiclient,forced="false")
+        templatevm.stop(self.user_api_client,forced="false")
 
         vm_response = VirtualMachine.list(
-                            self.apiclient,
+                            self.user_api_client,
                             id=templatevm.id)
 
         vm = vm_response[0]
@@ -1003,7 +1014,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                         )
 
         list_volume_response = Volume.list(
-            self.apiclient,
+            self.user_api_client,
             virtualmachineid=vm.id,
             type="ROOT",
             listall=True
@@ -1011,7 +1022,7 @@ class TestXDCCPInterop(cloudstackTestCase):
 
         #Create template from Virtual machine and Volume ID
         roottemplate = Template.create(
-                                self.apiclient,
+                                self.user_api_client,
                                 self.services["interop"]["template"],
                                 volumeid=list_volume_response[0].id,
                                 account=self.account.name,
@@ -1021,7 +1032,7 @@ class TestXDCCPInterop(cloudstackTestCase):
         time.sleep(600)
 
         list_template_response = Template.list(
-                                    self.apiclient,
+                                    self.user_api_client,
                                     templatefilter=\
                                     self.services["templatefilter"],
                                     id=roottemplate.id
@@ -1042,36 +1053,31 @@ class TestXDCCPInterop(cloudstackTestCase):
 
         self.assertEqual(
                             template_response.displaytext,
-                            self.services["template"]["displaytext"],
+                            self.services["interop"]["template"]["displaytext"],
                             "Check display text of newly created template"
                         )
         name = template_response.name
         self.assertEqual(
-                            name.count(self.services["template"]["name"]),
+                            name.count(self.services["interop"]["template"]["name"]),
                             1,
                             "Check name of newly created template"
                         )
-        self.assertEqual(
-                            template_response.ostypeid,
-                            self.services["template"]["ostypeid"],
-                            "Check osTypeID of newly created template"
-                        )
 
 
         templatevm.delete(self.apiclient)
-        vm2network.delete(self.apiclient)
+        vm2network.delete(self.user_api_client)
 
         vm3network=Network.create(
-                                 self.apiclient,
+                                 self.user_api_client,
                                 self.services["network"],
                                 accountid=self.account.name,
                                 domainid=self.account.domainid,
-                                networkofferingid=noffering.id,
+                                networkofferingid=noffering[0].id,
                                 zoneid=self.zone.id
                                  )
 
         list_nw_response = Network.list(
-                                            self.apiclient,
+                                            self.user_api_client,
                                             id=vm3network.id
                                             )
         self.assertEqual(
@@ -1082,7 +1088,7 @@ class TestXDCCPInterop(cloudstackTestCase):
 
 
         templatevm = VirtualMachine.create(
-                                    self.apiclient,
+                                    self.user_api_client,
                                     self.services["medium"],
                                     templateid=roottemplate.id,
                                     networkids=vm3network.id,
@@ -1094,7 +1100,7 @@ class TestXDCCPInterop(cloudstackTestCase):
                                     )
         time.sleep(600)
         vm_response = VirtualMachine.list(
-                            self.apiclient,
+                            self.user_api_client,
                             id=templatevm.id)
 
         self.assertNotEqual(
@@ -1110,10 +1116,10 @@ class TestXDCCPInterop(cloudstackTestCase):
                         )
 
         # Delete the template
-        roottemplate.delete(self.apiclient)
+        roottemplate.delete(self.user_api_client)
 
         list_template_response = Template.list(
-                                    self.apiclient,
+                                    self.user_api_client,
                                     templatefilter=\
                                     self.services["template"]["templatefilter"],
                                     id=roottemplate.id,
@@ -1127,5 +1133,204 @@ class TestXDCCPInterop(cloudstackTestCase):
 
         templatevm.delete(self.apiclient)
 
-        vm3network.delete(self.apiclient)
+        vm3network.delete(self.user_api_client)
+        return
+
+
+    @attr(tags=["devcloud", "basic", "advanced", "post"], required_hardware="true")
+    def test_17_deployvm_userdata_post(self):
+        """Test userdata as POST, size > 2k
+        """
+        deployVmResponse = VirtualMachine.create(
+            self.user_api_client,
+            services=self.services["virtual_machine"],
+            accountid=self.account.name,
+            domainid=self.account.domainid,
+            serviceofferingid=self.service_offering.id,
+            templateid=self.template.id,
+            zoneid=self.zone.id,
+            method='POST'
+        )
+        vms = list_virtual_machines(
+            self.user_api_client,
+            account=self.account.name,
+            domainid=self.account.domainid,
+            id=deployVmResponse.id
+        )
+        self.assert_(len(vms) > 0, "There are no Vms deployed in the account %s" % self.account.name)
+        vm = vms[0]
+        self.assert_(vm.id == str(deployVmResponse.id), "Vm deployed is different from the test")
+        self.assert_(vm.state == "Running", "VM is not in Running state")
+        return
+
+    @attr(tags=["devcloud", "basic", "advanced"], required_hardware="true")
+    def test_18_deployvm_userdata(self):
+        """Test userdata as GET, size > 2k
+        """
+        deployVmResponse = VirtualMachine.create(
+            self.user_api_client,
+            services=self.services["virtual_machine"],
+            accountid=self.account.name,
+            domainid=self.account.domainid,
+            serviceofferingid=self.service_offering.id,
+            templateid=self.template.id,
+            zoneid=self.zone.id
+        )
+        vms = list_virtual_machines(
+            self.user_api_client,
+            account=self.account.name,
+            domainid=self.account.domainid,
+            id=deployVmResponse.id
+        )
+        self.assert_(len(vms) > 0, "There are no Vms deployed in the account %s" % self.account.name)
+        vm = vms[0]
+        self.assert_(vm.id == str(deployVmResponse.id), "Vm deployed is different from the test")
+        self.assert_(vm.state == "Running", "VM is not in Running state")
+
+        return
+
+
+
+
+    @attr(tags=["advanced", "basic"], required_hardware="false")
+    def test_19_template_tag(self):
+        """ Test creation, listing and deletion tag on templates
+        """
+
+        if self.hypervisor.lower() in ['lxc']:
+            self.skipTest("template creation from volume feature is not supported on %s" % self.hypervisor.lower())
+
+        try:
+            
+            noffering=NetworkOffering.list(
+                     self.user_api_client,
+                     name="DefaultIsolatedNetworkOfferingWithSourceNatService"
+                     )
+            vm4network=Network.create(
+                                 self.user_api_client,
+                                self.services["network"],
+                                accountid=self.account.name,
+                                domainid=self.account.domainid,
+                                networkofferingid=noffering[0].id,
+                                zoneid=self.zone.id
+                                 )
+
+            list_nw_response = Network.list(
+                                            self.user_api_client,
+                                            id=vm4network.id
+                                            )
+            self.assertEqual(
+                            isinstance(list_nw_response, list),
+                            True,
+                            "Check list response returns a valid networks list"
+                        )
+
+            vm_1 = VirtualMachine.create(
+                                    self.user_api_client,
+                                    self.services["medium"],
+                                    templateid=template.id,
+                                    networkids=vm4network.id,
+                                    serviceofferingid=self.service_offering.id,
+                                    accountid=self.account.name,
+                                    domainid=self.account.domainid,
+                                    mode=self.services['mode'],
+                                    startvm="true"
+                                    )
+            time.sleep(600)
+            self.debug("Stopping the virtual machine: %s" % vm_1.name)
+            # Stop virtual machine
+            vm_1.stop(self.user_api_client)
+        except Exception as e:
+            self.fail("Failed to stop VM: %s" % e)
+
+        timeout = self.services["timeout"]
+        while True:
+            list_volume = Volume.list(
+                self.user_api_client,
+                virtualmachineid=vm_1.id,
+                type='ROOT',
+                listall=True
+            )
+            if isinstance(list_volume, list):
+                break
+            elif timeout == 0:
+                raise Exception("List volumes failed.")
+
+            time.sleep(5)
+            timeout = timeout - 1
+
+        self.volume = list_volume[0]
+
+        self.debug("Creating template from ROOT disk of virtual machine: %s" %
+                   vm_1.name)
+        # Create template from volume
+        template = Template.create(
+            self.user_api_client,
+            self.services["template"],
+            self.volume.id
+        )
+        self.cleanup.append(template)
+        self.debug("Created the template(%s). Now restarting the userVm: %s" %
+                   (template.name, vm_1.name))
+        vm_1.start(self.user_api_client)
+
+        self.debug("Creating a tag for the template")
+        tag = Tag.create(
+            self.user_api_client,
+            resourceIds=template.id,
+            resourceType='Template',
+            tags={'OS': 'windows8'}
+        )
+        self.debug("Tag created: %s" % tag.__dict__)
+
+        tags = Tag.list(
+            self.user_api_client,
+            listall=True,
+            resourceType='Template',
+            key='OS',
+            value='windows8'
+        )
+        self.assertEqual(
+            isinstance(tags, list),
+            True,
+            "List tags should not return empty response"
+        )
+        self.assertEqual(
+            tags[0].value,
+            'windows8',
+            'The tag should have original value'
+        )
+
+        Template.list(
+            self.user_api_client,
+            templatefilter=self.services["template"]["templatefilter"],
+            listall=True,
+            key='OS',
+            value='windows8'
+        )
+
+        self.debug("Deleting the created tag..")
+        try:
+            tag.delete(
+                self.user_api_client,
+                resourceIds=template.id,
+                resourceType='Template',
+                tags={'OS': 'windows8'}
+            )
+        except Exception as e:
+            self.fail("Failed to delete the tag - %s" % e)
+
+        self.debug("Verifying if tag is actually deleted!")
+        tags = Tag.list(
+            self.user_api_client,
+            listall=True,
+            resourceType='Template',
+            key='OS',
+            value='windows8'
+        )
+        self.assertEqual(
+            tags,
+            None,
+            "List tags should return empty response"
+        )
         return


[6/6] git commit: updated refs/heads/master to 4df55f1

Posted by sa...@apache.org.
Test data file update with Interop config changes


Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/4df55f19
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/4df55f19
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/4df55f19

Branch: refs/heads/master
Commit: 4df55f199ed41429292d12dd669379dcc836787b
Parents: 7887420
Author: sailajamada <sa...@citrix.com>
Authored: Mon Apr 20 17:21:42 2015 +0530
Committer: sailajamada <sa...@citrix.com>
Committed: Mon Apr 20 17:21:42 2015 +0530

----------------------------------------------------------------------
 tools/marvin/marvin/config/test_data.py | 7 +++++++
 1 file changed, 7 insertions(+)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cloudstack/blob/4df55f19/tools/marvin/marvin/config/test_data.py
----------------------------------------------------------------------
diff --git a/tools/marvin/marvin/config/test_data.py b/tools/marvin/marvin/config/test_data.py
index dc10338..e7244ac 100644
--- a/tools/marvin/marvin/config/test_data.py
+++ b/tools/marvin/marvin/config/test_data.py
@@ -133,6 +133,13 @@ test_data = {
             "cpuspeed": 100,
             "memory": 512,
         },
+       "large": {
+            "name": "LargeInstance",
+            "displaytext": "LargeInstance",
+            "cpunumber": 1,
+            "cpuspeed": 500,
+            "memory": 2048,
+        },
         "hasmall": {
             "name": "HA Small Instance",
             "displaytext": "HA Small Instance",


[4/6] git commit: updated refs/heads/master to 4df55f1

Posted by sa...@apache.org.
Merge branch 'master' of https://git-wip-us.apache.org/repos/asf/cloudstack


Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/ed7be383
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/ed7be383
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/ed7be383

Branch: refs/heads/master
Commit: ed7be383deef59470bda9ae6821dd4c17a2d1f7f
Parents: d08d60b 21ab280
Author: sailajamada <sa...@citrix.com>
Authored: Mon Apr 20 15:24:12 2015 +0530
Committer: sailajamada <sa...@citrix.com>
Committed: Mon Apr 20 15:24:12 2015 +0530

----------------------------------------------------------------------
 .../classes/resources/messages.properties       |   14 +-
 .../classes/resources/messages_ar.properties    |    6 -
 .../classes/resources/messages_ca.properties    |    5 -
 .../classes/resources/messages_de_DE.properties |  156 +-
 .../classes/resources/messages_es.properties    |   20 +-
 .../classes/resources/messages_fr_FR.properties |  165 +-
 .../classes/resources/messages_it_IT.properties |   10 +-
 .../classes/resources/messages_ja_JP.properties | 1451 +++++++++---------
 .../classes/resources/messages_ko_KR.properties |   12 +-
 .../classes/resources/messages_nb_NO.properties |   21 +-
 .../classes/resources/messages_nl_NL.properties |   21 +-
 .../classes/resources/messages_pl.properties    |   10 +-
 .../classes/resources/messages_pt_BR.properties |   24 +-
 .../classes/resources/messages_ru_RU.properties |   16 +-
 .../classes/resources/messages_zh_CN.properties | 1330 ++++++++--------
 .../component/test_multiple_ips_per_nic.py      |   42 +
 tools/transifex/.tx/config                      |   18 +
 17 files changed, 1699 insertions(+), 1622 deletions(-)
----------------------------------------------------------------------



[5/6] git commit: updated refs/heads/master to 4df55f1

Posted by sa...@apache.org.
Added size to Volume create wrapper


Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/7887420e
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/7887420e
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/7887420e

Branch: refs/heads/master
Commit: 7887420eba5aac3bac69f8d4b5dce7959a9782ae
Parents: ed7be38
Author: sailajamada <sa...@citrix.com>
Authored: Mon Apr 20 17:20:50 2015 +0530
Committer: sailajamada <sa...@citrix.com>
Committed: Mon Apr 20 17:20:50 2015 +0530

----------------------------------------------------------------------
 tools/marvin/marvin/config/test_data.py | 92 ++++++++++++++++++++++++++++
 tools/marvin/marvin/lib/base.py         |  6 +-
 2 files changed, 97 insertions(+), 1 deletion(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/cloudstack/blob/7887420e/tools/marvin/marvin/config/test_data.py
----------------------------------------------------------------------
diff --git a/tools/marvin/marvin/config/test_data.py b/tools/marvin/marvin/config/test_data.py
index 6c87374..dc10338 100644
--- a/tools/marvin/marvin/config/test_data.py
+++ b/tools/marvin/marvin/config/test_data.py
@@ -1071,6 +1071,16 @@ test_data = {
             "ispublic": "true",
             "hypervisor": "XenServer"
         },
+        "RHEL 7 (64-bit)": {
+                              "displaytext": "RHEL7 (64-bit)",
+                              "name": "RHEL 7 Insta1",
+                              "passwordenabled": False,
+                              "url": "http://10.147.28.7/templates/Rhel/RHEL764bit.vhd",
+                              "format": "VHD" ,
+                              "ostype": "RHEL 7 (64-bit)",
+                              "ispublic": "true",
+                              "hypervisor": "XenServer"
+                              },
         "clusters": {
             "clustername": "Xen Cluster Vgpu",
             "clustertype": "CloudManaged",
@@ -1533,6 +1543,88 @@ test_data = {
             }
         ]
     },
+
+"interop":
+    {
+     "VHD":
+     {
+                              "displaytext": "Windows 8 (64-bit)",
+                              "name": "win8withpvxen",
+                              "passwordenabled": False,
+                              "url": "http://10.147.28.7/templates/sailajaxd/XS65pvtemplates/win8/79211594-1d4a-4dee-ae6c-c5c315ded2be.vhd",
+                              "format": "VHD" ,
+                              "ostype": "Windows 8 (64-bit)",
+                              "ispublic": "true",
+                              "hypervisor": "XenServer"
+
+     },
+     "OVA":
+     {
+                              "displaytext": "Windows 8 (64-bit)",
+                              "name": "win8withpvvmware",
+                              "passwordenabled": False,
+                              "url": "http://pleaseupdateURL/",
+                              "format": "OVA" ,
+                              "ostype": "Windows 8 (64-bit)",
+                              "ispublic": "true",
+                              "hypervisor": "VMware"
+                              },
+    "template": {
+        "displaytext": "windowsxdtemplate",
+        "name": "windowsxdtemplate",
+        "passwordenabled": False,
+        "ostype": "Windows 8 (64-bit)"
+    },
+},
+
+    "browser_upload_volume":{
+          "VHD": {
+        "diskname": "XenUploadVol",
+        "url": "http://10.147.28.7/templates/rajani-thin-volume.vhd",
+        "checksum": "09b08b6abb1b903fca7711d3ac8d6598",
+                },
+          "OVA": {
+        "diskname": "VMwareUploadVol",
+        "url": "http://10.147.28.7/templates/Autoscale_Template/CentOS5.5(64bit)-vmware-autoscale.ova",
+        "checksum": "da997b697feaa2f1f6e0d4785b0cece2",
+                },
+          "QCOW2": {
+        "diskname": "KVMUploadVol",
+        "url": "http://10.147.28.7/templates/rajani-thin-volume.qcow2",
+        "checksum": "02de0576dd3a61ab59c03fd795fc86ac",
+                },
+    'browser_resized_disk_offering': {
+        "displaytext": "Resizeddisk",
+        "name": "Resizeddisk",
+        "disksize": 3,
+    }
+},
+    "browser_upload_template": {
+          "VHD": {
+        "templatename": "XenUploadtemplate",
+        "displaytext": "XenUploadtemplate",
+        "url": "http://10.147.28.7/templates/builtin/centos56-x86_64.vhd.bz2",
+        "hypervisor":"XenServer",
+        "checksum": "09b08b6abb1b903fca7711d3ac8d6598",
+        "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
+                },
+          "OVA": {
+        "templatename": "VMwareUploadtemplate",
+        "displaytext": "VMwareUploadtemplate",
+        "url": "http://nfs1.lab.vmops.com/templates/vmware/CentOS5.3-x86_64.ova",
+        "checksum": "02de0576dd3a61ab59c03fd795fc86ac",
+        "hypervisor":"VMware",
+        "ostypeid":"74affaea-c658-11e4-ad38-a6d1374244b4"
+                },
+          "QCOW2": {
+        "templatename": "KVMUploadtemplate",
+        "displaytext": "VMwareUploadtemplate",
+        "url": "http://10.147.28.7/templates/builtin/eec2209b-9875-3c8d-92be-c001bd8a0faf.qcow2.bz2",
+        "checksum": "da997b697feaa2f1f6e0d4785b0cece2",
+        "hypervisor":"KVM",
+        "ostypeid":"2e02e376-cdf3-11e4-beb3-8aa6272b57ef"
+                },
+                              },
     "configurableData":
         {
             "portableIpRange": {

http://git-wip-us.apache.org/repos/asf/cloudstack/blob/7887420e/tools/marvin/marvin/lib/base.py
----------------------------------------------------------------------
diff --git a/tools/marvin/marvin/lib/base.py b/tools/marvin/marvin/lib/base.py
index 44be8e8..0835b60 100755
--- a/tools/marvin/marvin/lib/base.py
+++ b/tools/marvin/marvin/lib/base.py
@@ -807,7 +807,7 @@ class Volume:
 
     @classmethod
     def create(cls, apiclient, services, zoneid=None, account=None,
-               domainid=None, diskofferingid=None, projectid=None):
+               domainid=None, diskofferingid=None, projectid=None ,size=None):
         """Create Volume"""
         cmd = createVolume.createVolumeCmd()
         cmd.name = "-".join([services["diskname"], random_gen()])
@@ -834,6 +834,10 @@ class Volume:
 
         if projectid:
             cmd.projectid = projectid
+
+        if size:
+            cmd.size = size
+
         return Volume(apiclient.createVolume(cmd).__dict__)
 
     @classmethod


[2/6] git commit: updated refs/heads/master to 4df55f1

Posted by sa...@apache.org.
Merge branch 'master' of https://git-wip-us.apache.org/repos/asf/cloudstack


Project: http://git-wip-us.apache.org/repos/asf/cloudstack/repo
Commit: http://git-wip-us.apache.org/repos/asf/cloudstack/commit/6db212d4
Tree: http://git-wip-us.apache.org/repos/asf/cloudstack/tree/6db212d4
Diff: http://git-wip-us.apache.org/repos/asf/cloudstack/diff/6db212d4

Branch: refs/heads/master
Commit: 6db212d4138a297a716ac3f2a438018e571bcf74
Parents: 9d0cc12 9593221
Author: sailajamada <sa...@citrix.com>
Authored: Fri Apr 17 17:24:37 2015 +0530
Committer: sailajamada <sa...@citrix.com>
Committed: Fri Apr 17 17:24:37 2015 +0530

----------------------------------------------------------------------
 .travis.yml                                     |    2 +-
 .../user/vmsnapshot/CreateVMSnapshotCmd.java    |    2 +-
 .../src/com/cloud/agent/api/PlugNicCommand.java |   14 +
 core/src/com/cloud/resource/CommandWrapper.java |    3 +-
 .../manager/ClusteredAgentManagerImpl.java      |   13 +-
 .../com/cloud/vm/VirtualMachineManagerImpl.java |    3 +-
 .../com/cloud/upgrade/dao/Upgrade450to451.java  |   51 +-
 .../allocator/StorageCacheRandomAllocator.java  |   20 +-
 .../manager/ImageStoreProviderManagerImpl.java  |   22 +
 .../storage/datastore/DataStoreManagerImpl.java |    7 +-
 .../datastore/ImageStoreProviderManager.java    |    2 +
 plugins/hypervisors/kvm/pom.xml                 |    2 +-
 .../kvm/resource/BridgeVifDriver.java           |    4 +-
 .../hypervisor/kvm/resource/IvsVifDriver.java   |    4 +-
 .../hypervisor/kvm/resource/LibvirtVMDef.java   |    4 +-
 .../hypervisor/kvm/resource/OvsVifDriver.java   |    4 +-
 .../com/cloud/hypervisor/guru/VMwareGuru.java   |   12 +-
 .../vmware/manager/VmwareManagerImpl.java       |    2 +-
 .../vmware/resource/VmwareResource.java         |   11 +-
 .../xenserver/resource/CitrixResourceBase.java  |   59 +-
 .../xenserver/resource/XenServer56Resource.java |   44 +-
 .../XenServer56NetworkUsageCommandWrapper.java  |    7 +-
 .../src/com/cloud/agent/api/BcfAnswer.java      |    6 +-
 .../src/com/cloud/agent/api/BcfCommand.java     |   14 +-
 .../agent/api/CacheBcfTopologyCommand.java      |    8 +-
 .../agent/api/CreateBcfAttachmentCommand.java   |   22 +-
 .../cloud/agent/api/CreateBcfRouterCommand.java |    4 +-
 .../api/CreateBcfRouterInterfaceCommand.java    |   14 +-
 .../agent/api/CreateBcfSegmentCommand.java      |   16 +-
 .../agent/api/CreateBcfStaticNatCommand.java    |   14 +-
 .../agent/api/DeleteBcfAttachmentCommand.java   |   10 +-
 .../agent/api/DeleteBcfSegmentCommand.java      |   10 +-
 .../agent/api/DeleteBcfStaticNatCommand.java    |    8 +-
 .../agent/api/GetControllerDataAnswer.java      |   25 +-
 .../agent/api/GetControllerDataCommand.java     |    2 -
 .../agent/api/GetControllerHostsAnswer.java     |    4 +-
 .../agent/api/GetControllerHostsCommand.java    |    4 +-
 .../cloud/agent/api/SyncBcfTopologyCommand.java |   14 +-
 .../agent/api/UpdateBcfAttachmentCommand.java   |   11 +-
 .../cloud/agent/api/UpdateBcfRouterCommand.java |   10 +-
 .../api/commands/AddBigSwitchBcfDeviceCmd.java  |   25 +-
 .../com/cloud/api/commands/BcfConstants.java    |    8 +-
 .../commands/DeleteBigSwitchBcfDeviceCmd.java   |   16 +-
 .../commands/ListBigSwitchBcfDevicesCmd.java    |   22 +-
 .../response/BigSwitchBcfDeviceResponse.java    |   16 +-
 .../com/cloud/network/BigSwitchBcfDeviceVO.java |   10 +-
 .../com/cloud/network/bigswitch/AclData.java    |   28 +-
 .../cloud/network/bigswitch/AttachmentData.java |   31 +-
 .../network/bigswitch/BigSwitchBcfApi.java      |  170 +-
 .../network/bigswitch/BigSwitchBcfUtils.java    |   14 +-
 .../network/element/BigSwitchBcfElement.java    |    9 +-
 .../network/resource/BigSwitchBcfResource.java  |   64 +-
 .../bigswitch/BigSwitchBcfUtilsTest.java        |   93 +
 plugins/pom.xml                                 |   27 +-
 pom.xml                                         |    1 +
 scripts/util/qemu-ivs-ifup                      |    8 +-
 scripts/vm/hypervisor/kvm/kvmheartbeat.sh       |    3 +-
 .../dispatch/ParamGenericValidationWorker.java  |    2 +-
 .../deploy/DeploymentPlanningManagerImpl.java   |    2 +-
 .../cloud/ha/HighAvailabilityManagerImpl.java   |   14 +-
 .../cloud/server/ConfigurationServerImpl.java   |   11 +-
 server/src/com/cloud/server/StatsCollector.java |    9 +
 .../ConsoleProxyPasswordBasedEncryptor.java     |   30 -
 .../com/cloud/storage/StorageManagerImpl.java   |   13 +-
 .../com/cloud/storage/VolumeApiServiceImpl.java |    4 +-
 .../template/HypervisorTemplateAdapter.java     |   13 +-
 server/src/com/cloud/vm/UserVmManagerImpl.java  |   16 +
 .../ConsoleProxyPasswordBasedEncryptor.java     |   30 -
 setup/db/db/schema-442to450.sql                 |    2 +
 setup/dev/advanced.cfg                          |    6 +
 .../debian/config/etc/logrotate.d/apache2       |    2 +-
 .../patches/debian/config/etc/logrotate.d/cloud |    1 +
 .../debian/config/etc/logrotate.d/conntrackd    |    1 +
 .../debian/config/etc/logrotate.d/dnsmasq       |    1 +
 .../patches/debian/config/etc/logrotate.d/ppp   |    1 +
 systemvm/patches/debian/config/etc/rc.local     |   13 +
 .../debian/config/opt/cloud/bin/configure.py    |    6 +-
 .../debian/config/opt/cloud/bin/cs/CsHelper.py  |   16 +-
 .../component/test_VirtualRouter_alerts.py      |   15 +-
 test/integration/component/test_accounts.py     | 1743 +++++++++---------
 .../component/test_shared_networks.py           |   79 +-
 .../component/test_vpc_vm_life_cycle.py         |   15 +-
 test/integration/smoke/test_network.py          |   18 +-
 .../testpaths/testpath_stopped_vm.py            |   20 +-
 .../testpaths/testpath_storage_migration.py     |    3 +-
 test/integration/testpaths/testpath_vmlc.py     |   22 +-
 .../testpaths/testpath_volumelifecycle.py       |    7 +-
 .../install_systemvm_packages.sh                |   24 +-
 tools/devcloud4/.gitignore                      |    4 +
 tools/devcloud4/README.md                       |  101 +
 tools/devcloud4/advanced/Berksfile              |   27 +
 tools/devcloud4/advanced/README.md              |   95 +
 tools/devcloud4/advanced/Vagrantfile            |  115 ++
 .../devcloud4/advanced/chef_configuration.json  |   24 +
 tools/devcloud4/advanced/marvin.cfg             |  124 ++
 tools/devcloud4/basic/Berksfile                 |   27 +
 tools/devcloud4/basic/README.md                 |   83 +
 tools/devcloud4/basic/Vagrantfile               |   81 +
 tools/devcloud4/basic/chef_configuration.json   |   22 +
 tools/devcloud4/basic/marvin.cfg                |  110 ++
 .../binary-installation-advanced/Berksfile      |   26 +
 .../binary-installation-advanced/Vagrantfile    |  119 ++
 .../chef_configuration.json                     |   37 +
 .../binary-installation-advanced/marvin.cfg.erb |  123 ++
 .../binary-installation-basic/Berksfile         |   26 +
 .../binary-installation-basic/Vagrantfile       |   83 +
 .../chef_configuration.json                     |   34 +
 .../binary-installation-basic/marvin.cfg.erb    |  109 ++
 .../common/binary-installation/README.md        |    0
 .../attributes/database_server.rb               |   22 +
 .../binary-installation/attributes/default.rb   |   38 +
 .../common/binary-installation/metadata.rb      |   42 +
 .../recipes/database_server.rb                  |   24 +
 .../binary-installation/recipes/default.rb      |   27 +
 .../recipes/management_server.rb                |   57 +
 .../binary-installation/recipes/nfsshares.rb    |   48 +
 tools/devcloud4/common/configure-network.sh     |   37 +
 .../common/development-installation/README.md   |    0
 .../attributes/database_server.rb               |   22 +
 .../attributes/default.rb                       |   29 +
 .../files/default/cloud-install-sys-tmplt       |  288 +++
 .../files/default/createtmplt.sh                |  239 +++
 .../common/development-installation/metadata.rb |   42 +
 .../recipes/database_server.rb                  |   24 +
 .../development-installation/recipes/default.rb |   27 +
 .../recipes/nfsshares.rb                        |   48 +
 .../recipes/system_templates.rb                 |   38 +
 tools/devcloud4/pom.xml                         |  112 ++
 tools/devcloud4/prefill.sql                     |   34 +
 tools/marvin/marvin/codes.py                    |   13 +
 tools/marvin/marvin/lib/common.py               |  144 +-
 tools/marvin/marvin/testSetupSuccess.py         |   46 +-
 tools/pom.xml                                   |    3 +-
 ui/scripts/accounts.js                          |    3 +
 ui/scripts/accountsWizard.js                    |    3 +
 ui/scripts/configuration.js                     |    9 +
 ui/scripts/events.js                            |    3 +
 ui/scripts/instances.js                         |    6 +
 ui/scripts/network.js                           |    9 +
 ui/scripts/projects.js                          |    3 +
 ui/scripts/regions.js                           |    3 +
 ui/scripts/sharedFunctions.js                   |    3 +
 ui/scripts/storage.js                           |    6 +
 ui/scripts/system.js                            |   27 +-
 utils/src/com/cloud/utils/nio/Link.java         |    2 +-
 .../cloudstack/utils/security/SSLUtils.java     |    2 +-
 .../hypervisor/vmware/mo/VirtualMachineMO.java  |   18 +-
 147 files changed, 4592 insertions(+), 1451 deletions(-)
----------------------------------------------------------------------