mirror of
https://github.com/apache/cloudstack.git
synced 2025-11-04 00:02:37 +01:00
1780 lines
67 KiB
Python
1780 lines
67 KiB
Python
# Licensed to the Apache Software Foundation (ASF) under one
|
|
# or more contributor license agreements. See the NOTICE file
|
|
# distributed with this work for additional information
|
|
# regarding copyright ownership. The ASF licenses this file
|
|
# to you under the Apache License, Version 2.0 (the
|
|
# "License"); you may not use this file except in compliance
|
|
# with the License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing,
|
|
# software distributed under the License is distributed on an
|
|
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
# KIND, either express or implied. See the License for the
|
|
# specific language governing permissions and limitations
|
|
# under the License.
|
|
""" P1 tests for Browser Based Upload Volumes
|
|
"""
|
|
# Import Local Modules
|
|
|
|
import marvin
|
|
from nose.plugins.attrib import attr
|
|
from marvin.cloudstackTestCase import cloudstackTestCase
|
|
import unittest
|
|
from marvin.cloudstackAPI import *
|
|
from marvin.lib.utils import *
|
|
from marvin.lib.base import *
|
|
from marvin.lib.common import *
|
|
from marvin.codes import FAILED
|
|
|
|
import requests
|
|
import random
|
|
import string
|
|
import time
|
|
_multiprocess_shared_ = True
|
|
|
|
class TestBrowseUploadVolume(cloudstackTestCase):
|
|
|
|
"""
|
|
Testing Browse Upload Volume Feature
|
|
"""
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.testClient = super(TestBrowseUploadVolume,cls).getClsTestClient()
|
|
#print cls.testClient.getParsedTestDataConfig()
|
|
cls.testdata = cls.testClient.getParsedTestDataConfig()
|
|
cls.apiclient = cls.testClient.getApiClient()
|
|
cls.hypervisor = cls.testClient.getHypervisorInfo()
|
|
cls._cleanup = []
|
|
cls.domain = get_domain(cls.apiclient)
|
|
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
|
|
cls.unsupportedHypervisor = False
|
|
hosts = list_hosts(
|
|
cls.apiclient,
|
|
type="Routing"
|
|
)
|
|
|
|
if cls.hypervisor.lower() in ['lxc']:
|
|
# Template creation from root volume is not supported in LXC
|
|
cls.unsupportedHypervisor = True
|
|
return
|
|
|
|
if hosts is None:
|
|
raise unittest.SkipTest(
|
|
"There are no hypervisor's available.Check listhosts response")
|
|
|
|
cls.account = Account.create(
|
|
cls.apiclient,
|
|
cls.testdata["account"],
|
|
domainid=cls.domain.id
|
|
)
|
|
cls._cleanup.append(cls.account)
|
|
|
|
cls.template = get_template(
|
|
cls.apiclient,
|
|
cls.zone.id)
|
|
|
|
if cls.template == FAILED:
|
|
raise unittest.SkipTest(
|
|
"Check for default cent OS template readiness ")
|
|
|
|
cls.service_offering = ServiceOffering.create(
|
|
cls.apiclient,
|
|
cls.testdata["service_offering"]
|
|
)
|
|
cls._cleanup.append(cls.service_offering)
|
|
cls.disk_offering = DiskOffering.create(
|
|
cls.apiclient,
|
|
cls.testdata["resized_disk_offering"],
|
|
custom=True
|
|
)
|
|
cls._cleanup.append(cls.disk_offering)
|
|
cls.project = Project.create(
|
|
cls.apiclient,
|
|
cls.testdata["project"],
|
|
account=cls.account.name,
|
|
domainid=cls.account.domainid
|
|
)
|
|
cls._cleanup.append(cls.project)
|
|
|
|
def setUp(self):
|
|
|
|
if "kvm" in self.hypervisor.lower():
|
|
self.test_template = registerTemplate.registerTemplateCmd()
|
|
self.test_template = registerTemplate.registerTemplateCmd()
|
|
self.test_template.checksum = "{SHA-1}" + "bf580a13f791d86acf3449a7b457a91a14389264"
|
|
self.test_template.hypervisor = self.hypervisor
|
|
self.test_template.zoneid = self.zone.id
|
|
self.test_template.name = 'test sha-1'
|
|
self.test_template.displaytext = 'test sha-1'
|
|
self.test_template.url = "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-kvm.qcow2.bz2"
|
|
self.test_template.format = "QCOW2"
|
|
self.test_template.ostypeid = self.getOsType("Other Linux (64-bit)")
|
|
self.md5 = "ada77653dcf1e59495a9e1ac670ad95f"
|
|
self.sha256 = "0efc03633f2b8f5db08acbcc5dc1be9028572dfd8f1c6c8ea663f0ef94b458c5"
|
|
|
|
if "vmware" in self.hypervisor.lower():
|
|
self.test_template = registerTemplate.registerTemplateCmd()
|
|
self.test_template = registerTemplate.registerTemplateCmd()
|
|
self.test_template.checksum = "{SHA-1}" + "b25d404de8335b4348ff01e49a95b403c90df466"
|
|
self.test_template.hypervisor = self.hypervisor
|
|
self.test_template.zoneid = self.zone.id
|
|
self.test_template.name = 'test sha-2333'
|
|
self.test_template.displaytext = 'test sha-1'
|
|
self.test_template.url = "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-vmware.ova"
|
|
self.test_template.format = "OVA"
|
|
self.test_template.ostypeid = self.getOsType(self, "Other Linux (64-bit)")
|
|
self.md5 = "d6d97389b129c7d898710195510bf4fb"
|
|
self.sha256 = "f57b59f118ab59284a70d6c63229d1de8f2d69bffc5a82b773d6c47e769c12d9"
|
|
|
|
if "xen" in self.hypervisor.lower():
|
|
self.test_template = registerTemplate.registerTemplateCmd()
|
|
self.test_template = registerTemplate.registerTemplateCmd()
|
|
self.test_template.checksum = "{SHA-1}" + "427fad501d0d8a1d63b8600a9a469fbf91191314"
|
|
self.test_template.hypervisor = self.hypervisor
|
|
self.test_template.zoneid = self.zone.id
|
|
self.test_template.name = 'test sha-2333'
|
|
self.test_template.displaytext = 'test sha-1'
|
|
self.test_template.url = "http://dl.openvm.eu/cloudstack/macchinina/x86_64/macchinina-xen.vhd.bz2"
|
|
self.test_template.format = "VHD"
|
|
self.test_template.ostypeid = self.getOsType("Other Linux (64-bit)")
|
|
self.md5 = "54ebc933e6e07ae58c0dc97dfd37c824"
|
|
self.sha256 = "bddd9876021d33df9792b71ae4b776598680ac68ecf55e9d9af33c80904cc1f3"
|
|
|
|
if self.unsupportedHypervisor:
|
|
self.skipTest("Skipping test because unsupported hypervisor\
|
|
%s" % self.hypervisor)
|
|
|
|
self.cleanup = []
|
|
|
|
def getOsType(self, param):
|
|
cmd = listOsTypes.listOsTypesCmd()
|
|
cmd.description = param
|
|
return self.apiclient.listOsTypes(cmd)[0].id
|
|
|
|
def __verify_values(self, expected_vals, actual_vals):
|
|
|
|
return_flag = True
|
|
|
|
if len(expected_vals) != len(actual_vals):
|
|
return False
|
|
|
|
keys = list(expected_vals.keys())
|
|
for i in range(0, len(expected_vals)):
|
|
exp_val = expected_vals[keys[i]]
|
|
act_val = actual_vals[keys[i]]
|
|
if exp_val == act_val:
|
|
return_flag = return_flag and True
|
|
else:
|
|
return_flag = return_flag and False
|
|
self.debug(
|
|
"expected Value: %s, is not matching with actual value:\
|
|
%s" %
|
|
(exp_val, act_val))
|
|
return return_flag
|
|
|
|
def validate_uploaded_template(self, apiclient, template_id, retries=70, interval=5):
|
|
"""Check if template download will finish in 1 minute"""
|
|
while retries > -1:
|
|
time.sleep(interval)
|
|
template_response = Template.list(
|
|
apiclient,
|
|
id=template_id,
|
|
zoneid=self.zone.id,
|
|
templatefilter='self'
|
|
)
|
|
|
|
if isinstance(template_response, list):
|
|
template = template_response[0]
|
|
if not hasattr(template, 'status') or not template or not template.status:
|
|
retries = retries - 1
|
|
continue
|
|
|
|
# If template is ready,
|
|
# template.status = Download Complete
|
|
# Downloading - x% Downloaded
|
|
# if Failed
|
|
# Error - Any other string
|
|
if 'Failed' in template.status:
|
|
raise Exception(
|
|
"Failed to download template: status - %s" %
|
|
template.status)
|
|
|
|
elif template.status == 'Download Complete' and template.isready:
|
|
return
|
|
|
|
elif 'Downloaded' in template.status:
|
|
retries = retries - 1
|
|
continue
|
|
|
|
elif 'Installing' not in template.status:
|
|
if retries >= 0:
|
|
retries = retries - 1
|
|
continue
|
|
raise Exception(
|
|
"Error in downloading template: status - %s" %
|
|
template.status)
|
|
|
|
else:
|
|
retries = retries - 1
|
|
raise Exception("Template download failed exception.")
|
|
|
|
def gettemplatelimts(self):
|
|
|
|
totalresourcelist=Account.list(
|
|
self.apiclient,
|
|
id=self.account.id
|
|
)
|
|
totaltemplates=totalresourcelist[0].templatetotal
|
|
|
|
return(totaltemplates)
|
|
|
|
def getstoragelimits(self, rtype):
|
|
|
|
cmd=updateResourceCount.updateResourceCountCmd()
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.resourcetype=rtype
|
|
|
|
response=self.apiclient.updateResourceCount(cmd)
|
|
|
|
totalstorage=response[0].resourcecount
|
|
|
|
return(totalstorage)
|
|
|
|
def browse_upload_template(self):
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
cmd.zoneid = self.test_template.zoneid
|
|
cmd.format = self.test_template.format
|
|
cmd.name=self.test_template.name + self.account.name + (random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.test_template.name + self.account.name + (random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.test_template.hypervisor
|
|
cmd.ostypeid=self.test_template.ostypeid
|
|
#cmd.isdynamicallyscalable="false"
|
|
#cmd.type="template"
|
|
getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
|
|
signt=getuploadparamsresponse.signature
|
|
posturl=getuploadparamsresponse.postURL
|
|
metadata=getuploadparamsresponse.metadata
|
|
expiredata=getuploadparamsresponse.expires
|
|
#url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
|
|
url=self.test_template.url
|
|
|
|
uploadfile = url.split('/')[-1]
|
|
r = requests.get(url, stream=True)
|
|
with open(uploadfile, 'wb') as f:
|
|
for chunk in r.iter_content(chunk_size=1024):
|
|
if chunk: # filter out keep-alive new chunks
|
|
f.write(chunk)
|
|
f.flush()
|
|
|
|
#uploadfile='rajani-thin-volume.vhd'
|
|
|
|
#files={'file':('rajani-thin-volume.vhd',open(uploadfile,'rb'),'application/octet-stream')}
|
|
|
|
#headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}
|
|
|
|
files={'file':(uploadfile,open(uploadfile,'rb'),'application/octet-stream')}
|
|
|
|
headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}
|
|
|
|
results = requests.post(posturl,files=files,headers=headers,verify=False)
|
|
|
|
print(results.status_code)
|
|
if results.status_code !=200:
|
|
self.fail("Upload is not fine")
|
|
|
|
self.validate_uploaded_template(self.apiclient, getuploadparamsresponse.id)
|
|
|
|
return(getuploadparamsresponse)
|
|
|
|
def browse_upload_template_with_out_zoneid(self):
|
|
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
cmd.format = self.test_template.format
|
|
cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.test_template.hypervisor
|
|
cmd.ostypeid=self.test_template.ostypeid
|
|
|
|
success= False
|
|
try:
|
|
getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
except Exception as ex:
|
|
if "Invalid Parameter" in str(ex):
|
|
success = True
|
|
self.assertEqual(
|
|
success,
|
|
True,
|
|
"Upload Template - verify upload Template API request is handled without mandatory params - zoneid ")
|
|
|
|
return
|
|
|
|
def browse_upload_template_with_out_ostypeid(self):
|
|
|
|
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
cmd.zoneid = self.zone.id
|
|
cmd.format = self.test_template.format
|
|
cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.test_template.hypervisor
|
|
|
|
success= False
|
|
try:
|
|
getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
except Exception as ex:
|
|
if "Invalid Parameter" in str(ex):
|
|
success = True
|
|
self.assertEqual(
|
|
success,
|
|
True,
|
|
"Upload Template - verify upload template API request is handled without mandatory params - ostypeid")
|
|
|
|
return
|
|
|
|
def browse_upload_template_with_projectid(self,projectid):
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
cmd.zoneid = self.zone.id
|
|
cmd.format = self.test_template.format
|
|
cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.test_template.hypervisor
|
|
cmd.ostypeid=self.test_template.ostypeid
|
|
cmd.projectid=projectid
|
|
#cmd.isdynamicallyscalable="false"
|
|
#cmd.type="template"
|
|
getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
|
|
signt=getuploadparamsresponse.signature
|
|
posturl=getuploadparamsresponse.postURL
|
|
metadata=getuploadparamsresponse.metadata
|
|
expiredata=getuploadparamsresponse.expires
|
|
#url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
|
|
url=self.test_template.url
|
|
|
|
uploadfile = url.split('/')[-1]
|
|
r = requests.get(url, stream=True)
|
|
with open(uploadfile, 'wb') as f:
|
|
for chunk in r.iter_content(chunk_size=1024):
|
|
if chunk: # filter out keep-alive new chunks
|
|
f.write(chunk)
|
|
f.flush()
|
|
|
|
files={'file':(uploadfile,open(uploadfile,'rb'),'application/octet-stream')}
|
|
|
|
headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}
|
|
|
|
results = requests.post(posturl,files=files,headers=headers,verify=False)
|
|
|
|
print(results.status_code)
|
|
if results.status_code !=200:
|
|
self.fail("Upload is not fine")
|
|
|
|
self.validate_uploaded_template(self.apiclient, getuploadparamsresponse.id)
|
|
|
|
return(getuploadparamsresponse)
|
|
|
|
def browse_upload_template_multiplezones(self,lzones):
|
|
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
cmd.zoneid ="-1"
|
|
cmd.format = self.test_template.format
|
|
cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.test_template.hypervisor
|
|
cmd.ostypeid=self.test_template.ostypeid
|
|
#cmd.isdynamicallyscalable="false"
|
|
#cmd.type="template"
|
|
getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
|
|
signt=getuploadparamsresponse.signature
|
|
posturl=getuploadparamsresponse.postURL
|
|
metadata=getuploadparamsresponse.metadata
|
|
expiredata=getuploadparamsresponse.expires
|
|
#url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
|
|
url=self.test_template.url
|
|
|
|
uploadfile = url.split('/')[-1]
|
|
r = requests.get(url, stream=True)
|
|
with open(uploadfile, 'wb') as f:
|
|
for chunk in r.iter_content(chunk_size=1024):
|
|
if chunk: # filter out keep-alive new chunks
|
|
f.write(chunk)
|
|
f.flush()
|
|
|
|
#uploadfile='rajani-thin-volume.vhd'
|
|
|
|
#files={'file':('rajani-thin-volume.vhd',open(uploadfile,'rb'),'application/octet-stream')}
|
|
|
|
#headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}
|
|
|
|
files={'file':(uploadfile,open(uploadfile,'rb'),'application/octet-stream')}
|
|
|
|
headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}
|
|
|
|
results = requests.post(posturl,files=files,headers=headers,verify=False)
|
|
|
|
print(results.status_code)
|
|
if results.status_code !=200:
|
|
self.fail("Upload is not fine")
|
|
|
|
for z1 in lzones:
|
|
self.validate_uploaded_template(self.apiclient, getuploadparamsresponse.id)
|
|
|
|
return(getuploadparamsresponse)
|
|
|
|
def uploadtemplate(self):
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
cmd.zoneid = self.zone.id
|
|
cmd.format = self.test_template.format
|
|
cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.test_template.hypervisor
|
|
cmd.ostypeid=self.test_template.ostypeid
|
|
#cmd.type="template"
|
|
getuploadparamsresponse=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
|
|
signt=getuploadparamsresponse.signature
|
|
posturl=getuploadparamsresponse.postURL
|
|
metadata=getuploadparamsresponse.metadata
|
|
expiredata=getuploadparamsresponse.expires
|
|
#url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
|
|
url=self.test_template.url
|
|
|
|
uploadfile = url.split('/')[-1]
|
|
r = requests.get(url, stream=True)
|
|
with open(uploadfile, 'wb') as f:
|
|
for chunk in r.iter_content(chunk_size=1024):
|
|
if chunk: # filter out keep-alive new chunks
|
|
f.write(chunk)
|
|
f.flush()
|
|
|
|
#uploadfile='rajani-thin-volume.vhd'
|
|
|
|
#files={'file':('rajani-thin-volume.vhd',open(uploadfile,'rb'),'application/octet-stream')}
|
|
|
|
#headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}
|
|
|
|
files={'file':(uploadfile,open(uploadfile,'rb'),'application/octet-stream')}
|
|
|
|
headers={'x-signature':signt,'x-metadata':metadata,'x-expires':expiredata}
|
|
|
|
results = requests.post(posturl,files=files,headers=headers,verify=False)
|
|
time.sleep(60)
|
|
|
|
print(results.status_code)
|
|
if results.status_code !=200:
|
|
self.fail("Upload is not fine")
|
|
|
|
return(getuploadparamsresponse)
|
|
|
|
def multiple_browse_upload_template(self):
|
|
|
|
templ1=self.uploadtemplate()
|
|
templ2=self.uploadtemplate()
|
|
templ3=self.uploadtemplate()
|
|
|
|
self.validate_uploaded_template(self.apiclient, templ1.id)
|
|
self.validate_uploaded_template(self.apiclient, templ2.id)
|
|
self.validate_uploaded_template(self.apiclient, templ3.id)
|
|
|
|
self.delete_template(templ1)
|
|
self.delete_template(templ2)
|
|
self.delete_template(templ3)
|
|
return
|
|
|
|
def validate_vm(self, apiclient, vm_id, state, retries=72, interval=5):
|
|
|
|
"""Check if vm will be running in 6 minute"""
|
|
while retries > -1:
|
|
time.sleep(interval)
|
|
vm_response = list_virtual_machines(
|
|
apiclient,
|
|
id=vm_id
|
|
)
|
|
|
|
if isinstance(vm_response, list):
|
|
vm = vm_response[0]
|
|
if not hasattr(vm, 'state'):
|
|
retries = retries - 1
|
|
continue
|
|
|
|
# If vm is Running for x number of retries
|
|
if vm.state == state:
|
|
return
|
|
|
|
else:
|
|
retries = retries - 1
|
|
continue
|
|
|
|
else:
|
|
retries = retries - 1
|
|
raise Exception("VM failed exception.")
|
|
|
|
def deploy_vm(self,template):
|
|
virtual_machine = VirtualMachine.create(
|
|
self.apiclient,
|
|
self.testdata["virtual_machine"],
|
|
templateid=template.id,
|
|
zoneid=self.zone.id,
|
|
accountid=self.account.name,
|
|
domainid=self.account.domainid,
|
|
serviceofferingid=self.service_offering.id,
|
|
)
|
|
self.validate_vm(self.apiclient, vm_id = virtual_machine.id, state="Running")
|
|
return(virtual_machine)
|
|
|
|
def attach_volume(self,vmlist,volid):
|
|
|
|
list_volume_response = Volume.list(
|
|
self.apiclient,
|
|
id=volid
|
|
)
|
|
print(list_volume_response[0])
|
|
vmlist.attach_volume(
|
|
self.apiclient,
|
|
list_volume_response[0]
|
|
)
|
|
list_volume_response = Volume.list(
|
|
self.apiclient,
|
|
virtualmachineid=vmlist.id,
|
|
type='DATADISK',
|
|
listall=True
|
|
)
|
|
self.assertNotEqual(
|
|
list_volume_response,
|
|
None,
|
|
"Check if volume exists in ListVolumes")
|
|
self.assertEqual(
|
|
isinstance(list_volume_response, list),
|
|
True,
|
|
"Check list volumes response for valid list")
|
|
self.validate_uploaded_volume(volid,'Ready')
|
|
|
|
def validate_uploaded_volume(self, volid, status):
|
|
list_volume_response = Volume.list(
|
|
self.apiclient,
|
|
id=volid,
|
|
listall=True
|
|
)
|
|
|
|
self.assertNotEqual(
|
|
list_volume_response,
|
|
None,
|
|
"Check if volume exists in ListTemplates"
|
|
)
|
|
|
|
self.assertEqual(
|
|
list_volume_response[0].status,
|
|
status,
|
|
"Check volume status in List Volumes"
|
|
)
|
|
return
|
|
|
|
def reboot_vm(self,vmdetails):
|
|
vmdetails.reboot(self.apiclient)
|
|
self.validate_vm(self.apiclient, vm_id=vmdetails.id, state="Running")
|
|
|
|
def stop_vm(self,vmdetails):
|
|
vmdetails.stop(self.apiclient)
|
|
self.validate_vm(self.apiclient, vm_id=vmdetails.id, state="Stopped")
|
|
|
|
def start_vm(self,vmdetails):
|
|
vmdetails.start(self.apiclient)
|
|
self.validate_vm(self.apiclient, vm_id=vmdetails.id, state="Running")
|
|
|
|
def vmoperations(self,vmdetails):
|
|
self.reboot_vm(vmdetails)
|
|
|
|
self.stop_vm(vmdetails)
|
|
|
|
self.start_vm(vmdetails)
|
|
|
|
def detach_volume(self,vmdetails,volid):
|
|
"""Detach a Volume attached to a VM
|
|
"""
|
|
list_volume_response = Volume.list(
|
|
self.apiclient,
|
|
id=volid
|
|
)
|
|
print(list_volume_response[0])
|
|
vmdetails.detach_volume(self.apiclient,list_volume_response[0])
|
|
|
|
# Sleep to ensure the current state will reflected in other calls
|
|
time.sleep(self.testdata["sleep"])
|
|
|
|
list_volume_response = Volume.list(
|
|
self.apiclient,
|
|
id=volid
|
|
)
|
|
self.assertNotEqual(
|
|
list_volume_response,
|
|
None,
|
|
"Check if volume exists in ListVolumes"
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_volume_response, list),
|
|
True,
|
|
"Check list volumes response for valid list"
|
|
)
|
|
volume = list_volume_response[0]
|
|
self.assertEqual(
|
|
volume.virtualmachineid,
|
|
None,
|
|
"Check if volume state (detached) is reflected"
|
|
)
|
|
|
|
self.assertEqual(
|
|
volume.vmname,
|
|
None,
|
|
"Check if volume state (detached) is reflected"
|
|
)
|
|
return
|
|
|
|
def restore_vm(self,vmdetails):
|
|
"""Test recover Virtual Machine
|
|
"""
|
|
cmd = restoreVirtualMachine.restoreVirtualMachineCmd()
|
|
cmd.virtualmachineid = vmdetails.id
|
|
self.apiclient.recoverVirtualMachine(cmd)
|
|
|
|
list_vm_response = list_virtual_machines(
|
|
self.apiclient,
|
|
id=vmdetails.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_vm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
|
|
self.assertNotEqual(
|
|
len(list_vm_response),
|
|
0,
|
|
"Check VM available in List Virtual Machines"
|
|
)
|
|
|
|
self.assertEqual(
|
|
list_vm_response[0].state,
|
|
"Running",
|
|
"Check virtual machine is in Running state"
|
|
)
|
|
|
|
return
|
|
|
|
def restore_vm_fail(self,vmdetails):
|
|
|
|
cmd = restoreVirtualMachine.restoreVirtualMachineCmd()
|
|
cmd.virtualmachineid = vmdetails.id
|
|
success= False
|
|
try:
|
|
self.apiclient.recoverVirtualMachine(cmd)
|
|
except Exception as ex:
|
|
if "isn't available in the zone" in str(ex):
|
|
success = True
|
|
self.assertEqual(
|
|
success,
|
|
True,
|
|
"Restore VM with Deleted Template - Verify Restore VM is handled when template with which VM created id deleted")
|
|
|
|
return
|
|
|
|
def deletevolume(self,volumeid):
|
|
"""Delete a Volume attached to a VM
|
|
"""
|
|
|
|
cmd = deleteVolume.deleteVolumeCmd()
|
|
cmd.id = volumeid
|
|
|
|
self.apiclient.deleteVolume(cmd)
|
|
|
|
list_volume_response = Volume.list(
|
|
self.apiclient,
|
|
id=volumeid,
|
|
type='DATADISK'
|
|
)
|
|
self.assertEqual(
|
|
list_volume_response,
|
|
None,
|
|
"Check if volume exists in ListVolumes"
|
|
)
|
|
return
|
|
|
|
def destroy_vm(self,vmdetails):
|
|
|
|
vmdetails.delete(self.apiclient, expunge=False)
|
|
|
|
list_vm_response = list_virtual_machines(
|
|
self.apiclient,
|
|
id=vmdetails.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_vm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
|
|
self.assertNotEqual(
|
|
len(list_vm_response),
|
|
0,
|
|
"Check VM available in List Virtual Machines"
|
|
)
|
|
|
|
self.assertEqual(
|
|
list_vm_response[0].state,
|
|
"Destroyed",
|
|
"Check virtual machine is in destroyed state"
|
|
)
|
|
return
|
|
|
|
def recover_destroyed_vm(self,vmdetails):
|
|
|
|
cmd = recoverVirtualMachine.recoverVirtualMachineCmd()
|
|
cmd.id = vmdetails.id
|
|
self.apiclient.recoverVirtualMachine(cmd)
|
|
|
|
list_vm_response = list_virtual_machines(
|
|
self.apiclient,
|
|
id=vmdetails.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_vm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
|
|
self.assertNotEqual(
|
|
len(list_vm_response),
|
|
0,
|
|
"Check VM available in List Virtual Machines"
|
|
)
|
|
|
|
self.assertEqual(
|
|
list_vm_response[0].state,
|
|
"Stopped",
|
|
"Check virtual machine is in Stopped state"
|
|
)
|
|
|
|
return
|
|
|
|
def expunge_vm(self,vmdetails):
|
|
|
|
self.debug("Expunge VM-ID: %s" % vmdetails.id)
|
|
|
|
cmd = destroyVirtualMachine.destroyVirtualMachineCmd()
|
|
cmd.id = vmdetails.id
|
|
self.apiclient.destroyVirtualMachine(cmd)
|
|
|
|
config = Configurations.list(
|
|
self.apiclient,
|
|
name='expunge.delay'
|
|
)
|
|
|
|
expunge_delay = int(config[0].value)
|
|
time.sleep(expunge_delay * 2)
|
|
|
|
#VM should be destroyed unless expunge thread hasn't run
|
|
#Wait for two cycles of the expunge thread
|
|
config = Configurations.list(
|
|
self.apiclient,
|
|
name='expunge.interval'
|
|
)
|
|
expunge_cycle = int(config[0].value)
|
|
wait_time = expunge_cycle * 4
|
|
while wait_time >= 0:
|
|
list_vm_response = list_virtual_machines(
|
|
self.apiclient,
|
|
id=vmdetails.id
|
|
)
|
|
if not list_vm_response:
|
|
break
|
|
self.debug("Waiting for VM to expunge")
|
|
time.sleep(expunge_cycle)
|
|
wait_time = wait_time - expunge_cycle
|
|
|
|
self.debug("listVirtualMachines response: %s" % list_vm_response)
|
|
|
|
self.assertEqual(list_vm_response,None,"Check Expunged virtual machine is in listVirtualMachines response")
|
|
return
|
|
|
|
list_vm_response = list_virtual_machines(
|
|
self.apiclient,
|
|
id=vmdetails.id
|
|
)
|
|
if isinstance(list_vm_response, list):
|
|
self.fail("VM has not been expunged")
|
|
|
|
def waitForSystemVMAgent(self, vmname):
|
|
timeout = self.testdata["timeout"]
|
|
|
|
while True:
|
|
list_host_response = list_hosts(
|
|
self.apiclient,
|
|
name=vmname
|
|
)
|
|
|
|
if list_host_response and list_host_response[0].state == 'Up':
|
|
break
|
|
|
|
if timeout == 0:
|
|
raise Exception("Timed out waiting for SSVM agent to be Up")
|
|
|
|
time.sleep(self.testdata["sleep"])
|
|
timeout = timeout - 1
|
|
|
|
def ssvm_internals(self):
|
|
|
|
list_ssvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='secondarystoragevm',
|
|
state='Running',
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_ssvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
ssvm = list_ssvm_response[0]
|
|
|
|
hosts = list_hosts(
|
|
self.apiclient,
|
|
id=ssvm.hostid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(hosts, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
host = hosts[0]
|
|
|
|
self.debug("Running SSVM check script")
|
|
|
|
if self.hypervisor.lower() in ('vmware', 'hyperv'):
|
|
#SSH into SSVMs is done via management server for Vmware and Hyper-V
|
|
result = get_process_status(
|
|
self.apiclient.connection.mgtSvr,
|
|
22,
|
|
self.apiclient.connection.user,
|
|
self.apiclient.connection.passwd,
|
|
ssvm.privateip,
|
|
"/usr/local/cloud/systemvm/ssvm-check.sh |grep -e ERROR -e WARNING -e FAIL",
|
|
hypervisor=self.hypervisor
|
|
)
|
|
else:
|
|
try:
|
|
host.user, host.passwd = get_host_credentials(self.config, host.ipaddress)
|
|
result = get_process_status(
|
|
host.ipaddress,
|
|
22,
|
|
host.user,
|
|
host.passwd,
|
|
ssvm.linklocalip,
|
|
"/usr/local/cloud/systemvm/ssvm-check.sh |grep -e ERROR -e WARNING -e FAIL"
|
|
)
|
|
except KeyError:
|
|
self.skipTest("Marvin configuration has no host credentials to check router services")
|
|
res = str(result)
|
|
self.debug("SSVM script output: %s" % res)
|
|
|
|
self.assertEqual(
|
|
res.count("ERROR"),
|
|
1,
|
|
"Check for Errors in tests"
|
|
)
|
|
|
|
self.assertEqual(
|
|
res.count("WARNING"),
|
|
1,
|
|
"Check for warnings in tests"
|
|
)
|
|
|
|
#Check status of cloud service
|
|
if self.hypervisor.lower() in ('vmware', 'hyperv'):
|
|
#SSH into SSVMs is done via management server for Vmware and Hyper-V
|
|
result = get_process_status(
|
|
self.apiclient.connection.mgtSvr,
|
|
22,
|
|
self.apiclient.connection.user,
|
|
self.apiclient.connection.passwd,
|
|
ssvm.privateip,
|
|
"systemctl is-active cloud",
|
|
hypervisor=self.hypervisor
|
|
)
|
|
else:
|
|
try:
|
|
host.user, host.passwd = get_host_credentials(self.config, host.ipaddress)
|
|
result = get_process_status(
|
|
host.ipaddress,
|
|
22,
|
|
host.user,
|
|
host.passwd,
|
|
ssvm.linklocalip,
|
|
"systemctl is-active cloud"
|
|
)
|
|
except KeyError:
|
|
self.skipTest("Marvin configuration has no host credentials to check router services")
|
|
res = str(result)
|
|
self.debug("Cloud Process status: %s" % res)
|
|
# Apache CloudStack service (type=secstorage) is running: process id: 2346
|
|
self.assertEqual(
|
|
res.count("active"),
|
|
1,
|
|
"Check cloud service is running or not"
|
|
)
|
|
return
|
|
|
|
def list_sec_storage_vm(self):
|
|
|
|
list_ssvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='secondarystoragevm',
|
|
state='Running',
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_ssvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
#Verify SSVM response
|
|
self.assertNotEqual(
|
|
len(list_ssvm_response),
|
|
0,
|
|
"Check list System VMs response"
|
|
)
|
|
|
|
list_zones_response = list_zones(self.apiclient)
|
|
|
|
self.assertEqual(
|
|
isinstance(list_zones_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
|
|
self.debug("Number of zones: %s" % len(list_zones_response))
|
|
self.debug("Number of SSVMs: %s" % len(list_ssvm_response))
|
|
# Number of Sec storage VMs = No of Zones
|
|
self.assertEqual(
|
|
len(list_ssvm_response),
|
|
len(list_zones_response),
|
|
"Check number of SSVMs with number of zones"
|
|
)
|
|
#For each secondary storage VM check private IP,
|
|
#public IP, link local IP and DNS
|
|
for ssvm in list_ssvm_response:
|
|
|
|
self.debug("SSVM state: %s" % ssvm.state)
|
|
self.assertEqual(
|
|
ssvm.state,
|
|
'Running',
|
|
"Check whether state of SSVM is running"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(ssvm, 'privateip'),
|
|
True,
|
|
"Check whether SSVM has private IP field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(ssvm, 'linklocalip'),
|
|
True,
|
|
"Check whether SSVM has link local IP field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(ssvm, 'publicip'),
|
|
True,
|
|
"Check whether SSVM has public IP field"
|
|
)
|
|
|
|
#Fetch corresponding ip ranges information from listVlanIpRanges
|
|
ipranges_response = list_vlan_ipranges(
|
|
self.apiclient,
|
|
zoneid=ssvm.zoneid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(ipranges_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
iprange = ipranges_response[0]
|
|
|
|
#Fetch corresponding Physical Network of SSVM's Zone
|
|
listphyntwk = PhysicalNetwork.list(
|
|
self.apiclient,
|
|
zoneid=ssvm.zoneid
|
|
)
|
|
|
|
# Execute the following assertion in all zones except EIP-ELB Zones
|
|
if not (self.zone.networktype.lower() == 'basic' and isinstance(NetScaler.list(self.apiclient,physicalnetworkid=listphyntwk[0].id), list) is True):
|
|
self.assertEqual(
|
|
ssvm.gateway,
|
|
iprange.gateway,
|
|
"Check gateway with that of corresponding ip range"
|
|
)
|
|
|
|
#Fetch corresponding zone information from listZones
|
|
zone_response = list_zones(
|
|
self.apiclient,
|
|
id=ssvm.zoneid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(zone_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
self.assertEqual(
|
|
ssvm.dns1,
|
|
zone_response[0].dns1,
|
|
"Check DNS1 with that of corresponding zone"
|
|
)
|
|
|
|
self.assertEqual(
|
|
ssvm.dns2,
|
|
zone_response[0].dns2,
|
|
"Check DNS2 with that of corresponding zone"
|
|
)
|
|
return
|
|
|
|
def stop_ssvm(self):
|
|
|
|
list_ssvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='secondarystoragevm',
|
|
state='Running',
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_ssvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
ssvm = list_ssvm_response[0]
|
|
|
|
hosts = list_hosts(
|
|
self.apiclient,
|
|
id=ssvm.hostid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(hosts, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
host = hosts[0]
|
|
|
|
self.debug("Stopping SSVM: %s" % ssvm.id)
|
|
cmd = stopSystemVm.stopSystemVmCmd()
|
|
cmd.id = ssvm.id
|
|
self.apiclient.stopSystemVm(cmd)
|
|
|
|
timeout = self.testdata["timeout"]
|
|
while True:
|
|
list_ssvm_response = list_ssvms(
|
|
self.apiclient,
|
|
id=ssvm.id
|
|
)
|
|
if isinstance(list_ssvm_response, list):
|
|
if list_ssvm_response[0].state == 'Running':
|
|
break
|
|
if timeout == 0:
|
|
raise Exception("List SSVM call failed!")
|
|
|
|
time.sleep(self.testdata["sleep"])
|
|
timeout = timeout - 1
|
|
|
|
self.assertEqual(
|
|
isinstance(list_ssvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
ssvm_response = list_ssvm_response[0]
|
|
self.debug("SSVM state after debug: %s" % ssvm_response.state)
|
|
self.assertEqual(
|
|
ssvm_response.state,
|
|
'Running',
|
|
"Check whether SSVM is running or not"
|
|
)
|
|
# Wait for the agent to be up
|
|
self.waitForSystemVMAgent(ssvm_response.name)
|
|
|
|
# Call above tests to ensure SSVM is properly running
|
|
self.list_sec_storage_vm()
|
|
|
|
def reboot_ssvm(self):
|
|
|
|
list_ssvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='secondarystoragevm',
|
|
state='Running',
|
|
zoneid=self.zone.id
|
|
)
|
|
|
|
self.assertEqual(
|
|
isinstance(list_ssvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
|
|
ssvm_response = list_ssvm_response[0]
|
|
|
|
hosts = list_hosts(
|
|
self.apiclient,
|
|
id=ssvm_response.hostid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(hosts, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
host = hosts[0]
|
|
|
|
#Store the public & private IP values before reboot
|
|
old_public_ip = ssvm_response.publicip
|
|
old_private_ip = ssvm_response.privateip
|
|
|
|
self.debug("Rebooting SSVM: %s" % ssvm_response.id)
|
|
cmd = rebootSystemVm.rebootSystemVmCmd()
|
|
cmd.id = ssvm_response.id
|
|
self.apiclient.rebootSystemVm(cmd)
|
|
|
|
timeout = self.testdata["timeout"]
|
|
while True:
|
|
list_ssvm_response = list_ssvms(
|
|
self.apiclient,
|
|
id=ssvm_response.id
|
|
)
|
|
if isinstance(list_ssvm_response, list):
|
|
if list_ssvm_response[0].state == 'Running':
|
|
break
|
|
if timeout == 0:
|
|
raise Exception("List SSVM call failed!")
|
|
|
|
time.sleep(self.testdata["sleep"])
|
|
timeout = timeout - 1
|
|
|
|
ssvm_response = list_ssvm_response[0]
|
|
self.debug("SSVM State: %s" % ssvm_response.state)
|
|
self.assertEqual(
|
|
'Running',
|
|
str(ssvm_response.state),
|
|
"Check whether CPVM is running or not"
|
|
)
|
|
|
|
self.assertEqual(
|
|
ssvm_response.publicip,
|
|
old_public_ip,
|
|
"Check Public IP after reboot with that of before reboot"
|
|
)
|
|
|
|
self.assertEqual(
|
|
ssvm_response.privateip,
|
|
old_private_ip,
|
|
"Check Private IP after reboot with that of before reboot"
|
|
)
|
|
|
|
# Wait for the agent to be up
|
|
self.waitForSystemVMAgent(ssvm_response.name)
|
|
|
|
return
|
|
|
|
def destroy_ssvm(self):
|
|
|
|
list_ssvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='secondarystoragevm',
|
|
state='Running',
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_ssvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
ssvm_response = list_ssvm_response[0]
|
|
|
|
old_name = ssvm_response.name
|
|
|
|
self.debug("Destroying SSVM: %s" % ssvm_response.id)
|
|
cmd = destroySystemVm.destroySystemVmCmd()
|
|
cmd.id = ssvm_response.id
|
|
self.apiclient.destroySystemVm(cmd)
|
|
|
|
timeout = self.testdata["timeout"]
|
|
while True:
|
|
list_ssvm_response = list_ssvms(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
systemvmtype='secondarystoragevm'
|
|
)
|
|
if isinstance(list_ssvm_response, list):
|
|
if list_ssvm_response[0].state == 'Running':
|
|
break
|
|
if timeout == 0:
|
|
raise Exception("List SSVM call failed!")
|
|
|
|
time.sleep(self.testdata["sleep"])
|
|
timeout = timeout - 1
|
|
|
|
ssvm_response = list_ssvm_response[0]
|
|
|
|
# Verify Name, Public IP, Private IP and Link local IP
|
|
# for newly created SSVM
|
|
self.assertNotEqual(
|
|
ssvm_response.name,
|
|
old_name,
|
|
"Check SSVM new name with name of destroyed SSVM"
|
|
)
|
|
self.assertEqual(
|
|
hasattr(ssvm_response, 'privateip'),
|
|
True,
|
|
"Check whether SSVM has private IP field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(ssvm_response, 'linklocalip'),
|
|
True,
|
|
"Check whether SSVM has link local IP field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(ssvm_response, 'publicip'),
|
|
True,
|
|
"Check whether SSVM has public IP field"
|
|
)
|
|
|
|
# Wait for the agent to be up
|
|
self.waitForSystemVMAgent(ssvm_response.name)
|
|
|
|
return
|
|
|
|
def create_data_volume(self):
|
|
|
|
diskoffering = DiskOffering.list(self.apiclient)
|
|
self.assertTrue(
|
|
isinstance(
|
|
diskoffering,
|
|
list),
|
|
msg="DiskOffering list is not a list?")
|
|
self.assertTrue(
|
|
len(diskoffering) > 0,
|
|
"no disk offerings in the deployment")
|
|
|
|
vol = Volume.create(
|
|
self.apiclient,
|
|
services=self.testdata["volume"],
|
|
zoneid=self.zone.id,
|
|
account=self.account.name,
|
|
domainid=self.domain.id,
|
|
diskofferingid=diskoffering[0].id
|
|
)
|
|
self.assertTrue(
|
|
vol is not None, "volume creation fails in domain %s as user %s" %
|
|
(self.domain.name, self.account.name))
|
|
|
|
listed_vol = Volume.list(self.apiclient, id=vol.id)
|
|
self.assertTrue(
|
|
listed_vol is not None and isinstance(
|
|
listed_vol,
|
|
list),
|
|
"invalid response from listVolumes for volume %s" %
|
|
vol.id)
|
|
self.assertTrue(
|
|
listed_vol[0].id == vol.id,
|
|
"Volume returned by list volumes %s not matching with queried\
|
|
volume %s in domain %s" %
|
|
(listed_vol[0].id,
|
|
vol.id,
|
|
self.account.name))
|
|
return(listed_vol[0])
|
|
|
|
def attach_data_volume(self,volume,vmdetails):
|
|
|
|
list_volume_response = Volume.list(
|
|
self.apiclient,
|
|
id=volume.id
|
|
)
|
|
self.assertNotEqual(
|
|
list_volume_response,
|
|
None,
|
|
"Check if volume exists in ListVolumes"
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_volume_response, list),
|
|
True,
|
|
"Check list volumes response for valid list"
|
|
)
|
|
volume = list_volume_response[0]
|
|
|
|
self.assertEqual(
|
|
volume.type,
|
|
'DATADISK',
|
|
"Check volume type from list volume response"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(volume, 'vmname'),
|
|
True,
|
|
"Check whether volume has vmname field"
|
|
)
|
|
self.assertEqual(
|
|
hasattr(volume, 'virtualmachineid'),
|
|
True,
|
|
"Check whether volume has virtualmachineid field"
|
|
)
|
|
|
|
# Attach volume to VM
|
|
self.debug("Attach volume: %s to VM: %s" % (
|
|
volume.id,
|
|
vmdetails.id
|
|
))
|
|
vmdetails.attach_volume(self.apiclient, volume)
|
|
|
|
# Check all volumes attached to same VM
|
|
list_volume_response = Volume.list(
|
|
self.apiclient,
|
|
virtualmachineid=vmdetails.id,
|
|
type='DATADISK',
|
|
listall=True
|
|
)
|
|
self.assertNotEqual(
|
|
list_volume_response,
|
|
None,
|
|
"Check if volume exists in ListVolumes"
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_volume_response, list),
|
|
True,
|
|
"Check list volumes response for valid list"
|
|
)
|
|
volume = list_volume_response[0]
|
|
self.assertEqual(
|
|
volume.vmname,
|
|
vmdetails.name,
|
|
"Check virtual machine name in list volumes response"
|
|
)
|
|
self.assertEqual(
|
|
volume.virtualmachineid,
|
|
vmdetails.id,
|
|
"Check VM ID in list Volume response"
|
|
)
|
|
return
|
|
|
|
def delete_template(self,templatedetails):
|
|
|
|
list_template_response = Template.list(
|
|
self.apiclient,
|
|
templatefilter="all",
|
|
id=templatedetails.id,
|
|
zoneid=self.zone.id)
|
|
|
|
if list_template_response is None:
|
|
self.debug("Template is not available")
|
|
return
|
|
|
|
cmd = deleteTemplate.deleteTemplateCmd()
|
|
cmd.id = templatedetails.id
|
|
self.apiclient.deleteTemplate(cmd)
|
|
|
|
list_template_response = Template.list(
|
|
self.apiclient,
|
|
templatefilter="all",
|
|
id=templatedetails.id,
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
list_template_response,
|
|
None,
|
|
"Check template available in List Templates"
|
|
)
|
|
return
|
|
|
|
def detach_data_volume(self,volume,vmdetails):
|
|
|
|
self.debug("Detach volume: %s to VM: %s" % (
|
|
volume.id,
|
|
vmdetails.id
|
|
))
|
|
vmdetails.detach_volume(self.apiclient, volume)
|
|
|
|
# Sleep to ensure the current state will reflected in other calls
|
|
time.sleep(self.testdata["sleep"])
|
|
|
|
list_volume_response = Volume.list(
|
|
self.apiclient,
|
|
id=volume.id
|
|
)
|
|
self.assertNotEqual(
|
|
list_volume_response,
|
|
None,
|
|
"Check if volume exists in ListVolumes"
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_volume_response, list),
|
|
True,
|
|
"Check list volumes response for valid list"
|
|
)
|
|
volumelist = list_volume_response[0]
|
|
self.assertEqual(
|
|
volumelist.virtualmachineid,
|
|
None,
|
|
"Check if volume state (detached) is reflected"
|
|
)
|
|
|
|
self.assertEqual(
|
|
volumelist.vmname,
|
|
None,
|
|
"Check if volume state (detached) is reflected"
|
|
)
|
|
return
|
|
|
|
# was tags = ["advanced", "advancedns", "smoke", "basic"]
|
|
@attr(tags = ["TODO"], required_hardware="true")
|
|
def test_01_Browser_template_Life_cycle_tpath(self):
|
|
"""
|
|
Test Browser_template_Life_cycle
|
|
"""
|
|
#try:
|
|
|
|
self.debug("========================= Test 1: Upload Browser based template and validate ========================= ")
|
|
browseup_template=self.browse_upload_template()
|
|
|
|
self.debug("========================= Test 2: Deploy a VM with uploaded template and validate VM Operations========================= ")
|
|
|
|
vm1details=self.deploy_vm(browseup_template)
|
|
|
|
self.vmoperations(vm1details)
|
|
|
|
self.debug("========================= Test 3: Attach DATA DISK to the VM ")
|
|
|
|
cvolume=self.create_data_volume()
|
|
self.attach_data_volume(cvolume, vm1details)
|
|
self.vmoperations(vm1details)
|
|
|
|
self.debug("========================= Test 4: Restore VM created with Uploaded template========================= ")
|
|
|
|
self.restore_vm(vm1details)
|
|
|
|
self.debug("========================= Test 5: Detach DATA DISK to the VM ")
|
|
|
|
self.detach_data_volume(cvolume,vm1details)
|
|
self.vmoperations(vm1details)
|
|
|
|
self.deletevolume(cvolume.id)
|
|
|
|
|
|
self.debug("========================= Test 6: Expunge VM created with Uploaded template========================= ")
|
|
|
|
self.expunge_vm(vm1details)
|
|
|
|
self.debug("========================= Test 7: Destroy VM ========================= ")
|
|
|
|
vm2details=self.deploy_vm(self.template)
|
|
|
|
vm2details=self.deploy_vm(browseup_template)
|
|
self.destroy_vm(vm2details)
|
|
|
|
self.debug("========================= Test 8: Recover destroyed VM which has Uploaded volumes attached========================= ")
|
|
|
|
self.recover_destroyed_vm(vm2details)
|
|
self.expunge_vm(vm2details)
|
|
|
|
self.debug("========================= Test 9: Delete the Uploaded Template========================= ")
|
|
self.debug(browseup_template)
|
|
self.delete_template(browseup_template)
|
|
|
|
self.debug("========================= Test 10: Upload Multiple templates========================= ")
|
|
|
|
self.multiple_browse_upload_template()
|
|
|
|
# except Exception as e:
|
|
# self.fail("Exception occurred : %s" % e)
|
|
return
|
|
|
|
# was tags = ["advanced", "advancedns", "smoke", "basic"]
|
|
@attr(tags = ["TODO"], required_hardware="true")
|
|
def test_02_SSVM_Life_Cycle_With_Browser_Template_TPath(self):
|
|
"""
|
|
Test SSVM_Life_Cycle_With_Browser_template_TPath
|
|
"""
|
|
try:
|
|
|
|
self.debug("========================= Test 11: Stop and Start SSVM and Perform Browser based volume validations ========================= ")
|
|
|
|
self.stop_ssvm()
|
|
ssvm1browseup_template=self.browse_upload_template()
|
|
|
|
ssvm1vm1details=self.deploy_vm(ssvm1browseup_template)
|
|
#ssvm1vm1details=self.deploy_vm(self.template)
|
|
|
|
self.vmoperations(ssvm1vm1details)
|
|
|
|
self.expunge_vm(ssvm1vm1details)
|
|
|
|
self.debug("========================= Test 12: Reboot SSVM and Perform Browser based volume validations ========================= ")
|
|
|
|
self.reboot_ssvm()
|
|
ssvm2browseup_template=self.browse_upload_template()
|
|
|
|
ssvm2vm1details=self.deploy_vm(ssvm2browseup_template)
|
|
|
|
#ssvm2vm1details=self.deploy_vm(self.template)
|
|
self.vmoperations(ssvm2vm1details)
|
|
|
|
self.expunge_vm(ssvm2vm1details)
|
|
|
|
self.debug("========================= Test 13: Destroy SSVM and Perform Browser based volume validations ========================= ")
|
|
|
|
self.destroy_ssvm()
|
|
ssvm3browseup_template=self.browse_upload_template()
|
|
|
|
ssvm3vm1details=self.deploy_vm(ssvm3browseup_template)
|
|
|
|
#ssvm2vm1details=self.deploy_vm(self.template)
|
|
self.vmoperations(ssvm3vm1details)
|
|
|
|
self.expunge_vm(ssvm3vm1details)
|
|
|
|
except Exception as e:
|
|
self.fail("Exception occurred : %s" % e)
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
|
|
def test_03_Browser_template_upload_multiple_zones(self):
|
|
"""
|
|
Test Browser_template_upload_multiple_zones
|
|
"""
|
|
|
|
cmd = listZones.listZonesCmd()
|
|
zonelist=self.apiclient.listZones(cmd)
|
|
if len(zonelist) <2:
|
|
raise self.skipTest("Only one zone available hence skipping")
|
|
try:
|
|
|
|
self.debug("========================= Test 14: Upload Browser based template into multiple zones ========================= ")
|
|
browseup_template=self.browse_upload_template_multiplezones(zonelist)
|
|
|
|
except Exception as e:
|
|
self.fail("Exception occurred : %s" % e)
|
|
return
|
|
|
|
# was tags = ["advanced", "advancedns", "smoke", "basic"]
|
|
@attr(tags = ["TODO"], required_hardware="true")
|
|
def test_04_Browser_template_ResetVM_With_Deleted_Template(self):
|
|
"""
|
|
Test Browser_template_upload_ResetVM_With_Deleted_Template
|
|
"""
|
|
try:
|
|
|
|
self.debug("========================= Test 15: Test Browser_template_upload_ResetVM_With_Deleted_Template ========================= ")
|
|
|
|
browseup_template=self.browse_upload_template()
|
|
|
|
vm1details=self.deploy_vm(browseup_template)
|
|
|
|
self.delete_template(browseup_template)
|
|
|
|
self.restore_vm_fail(vm1details)
|
|
|
|
except Exception as e:
|
|
self.fail("Exception occurred : %s" % e)
|
|
return
|
|
|
|
# was tags = ["advanced", "advancedns", "smoke", "basic"]
|
|
@attr(tags = ["TODO"], required_hardware="true")
|
|
def test_05_Browser_Upload_Template_with_all_API_parameters(self):
|
|
"""
|
|
Test Browser_Upload_Template with all API parameters
|
|
"""
|
|
try:
|
|
|
|
self.debug("========================= Test 16 & 17 Upload template with account name and domainid========================")
|
|
|
|
browseup_template1=self.browse_upload_template()
|
|
|
|
self.debug("========================= Test 18 Upload template with project id========================")
|
|
browseup_template2=self.browse_upload_template_with_projectid(self.project.id)
|
|
|
|
self.debug("========================= Test 19 Upload template with out mandatory param zone id ========================")
|
|
|
|
browseup_vol2=self.browse_upload_template_with_out_zoneid()
|
|
|
|
self.debug("========================= Test 20 Upload template with out mandatory param ostypeid ========================")
|
|
|
|
browseup_vol3=self.browse_upload_template_with_out_ostypeid()
|
|
|
|
except Exception as e:
|
|
self.fail("Exception occurred : %s" % e)
|
|
return
|
|
|
|
# was tags = ["advanced", "advancedns", "smoke", "basic"]
|
|
@attr(tags = ["TODO"], required_hardware="true")
|
|
def test_06_Browser_Upload_template_resource_limits(self):
|
|
"""
|
|
Test Browser Upload Template Resource limits
|
|
"""
|
|
try:
|
|
|
|
self.debug("========================= Test 21 Upload Template and verify Template limits========================")
|
|
initialtemplatelimit=self.gettemplatelimts()
|
|
browseup_template1=self.browse_upload_template()
|
|
# Adding time for limit to sync in background
|
|
time.sleep(120)
|
|
afteruploadtemplatelimit=self.gettemplatelimts()
|
|
|
|
if int(afteruploadtemplatelimit)!=(int(initialtemplatelimit)+1):
|
|
self.fail("Volume Resource Count is not updated")
|
|
|
|
self.delete_template(browseup_template1)
|
|
|
|
except Exception as e:
|
|
self.fail("Exception occurred : %s" % e)
|
|
return
|
|
|
|
# was tags = ["advanced", "advancedns", "smoke", "basic"]
|
|
@attr(tags = ["TODO"], required_hardware="true")
|
|
def test_07_Browser_Upload_template_secondary_storage_resource_limits(self):
|
|
"""
|
|
Test Browser_Upload_Template Secondary Storage Resource limits
|
|
"""
|
|
try:
|
|
|
|
self.debug("========================= Test 22 Upload template and verify secondary storage limits========================")
|
|
|
|
initialsecondarystoragelimit=self.getstoragelimits(11)
|
|
browseup_template1=self.browse_upload_template()
|
|
|
|
tmpldetails=Template.list(
|
|
self.apiclient,
|
|
id=browseup_template1.id,
|
|
templatefilter="all",
|
|
zoneid=self.zone.id)
|
|
|
|
|
|
afteruploadsecondarystoragelimit=self.getstoragelimits(11)
|
|
|
|
if afteruploadsecondarystoragelimit!=(initialsecondarystoragelimit+tmpldetails[0].size):
|
|
self.fail("Secondary Storage Resource Count is not updated")
|
|
|
|
self.delete_template(browseup_template1)
|
|
|
|
except Exception as e:
|
|
self.fail("Exception occurred : %s" % e)
|
|
return
|
|
|
|
# was tags = ["advanced", "advancedns", "smoke", "basic"]
|
|
@attr(tags = ["TODO"], required_hardware="true")
|
|
def test_08_Browser_Upload_template_resource_limits_after_deletion(self):
|
|
"""
|
|
Test Browser_Upload_Template Resource limits after template deletion
|
|
"""
|
|
try:
|
|
self.debug("========================= Test 23 Delete Upload template and verify template limits========================")
|
|
browseup_template1=self.browse_upload_template()
|
|
initialtemplatelimit=self.gettemplatelimts()
|
|
|
|
self.delete_template(browseup_template1)
|
|
aftertemplatelimit=self.gettemplatelimts()
|
|
|
|
if aftertemplatelimit!=(initialtemplatelimit-1):
|
|
self.fail("Template Resource Count is not updated after deletion")
|
|
|
|
except Exception as e:
|
|
self.fail("Exceptione occurred : %s" % e)
|
|
return
|
|
|
|
# was tags = ["advanced", "advancedns", "smoke", "basic"]
|
|
@attr(tags = ["TODO"], required_hardware="true")
|
|
def test_09_Browser_Upload_Volume_secondary_storage_resource_limits_after_deletion(self):
|
|
"""
|
|
Test Browser_Upload_Template Secondary Storage Resource limits after template deletion
|
|
"""
|
|
try:
|
|
self.debug("========================= Test 24 Delete Upload template and verify secondary storage limits========================")
|
|
|
|
browseup_template1=self.browse_upload_template()
|
|
|
|
tmpldetails=Template.list(
|
|
self.apiclient,
|
|
id=browseup_template1.id,
|
|
templatefilter="all",
|
|
zoneid=self.zone.id)
|
|
|
|
initialuploadprimarystoragelimit=self.getstoragelimits(11)
|
|
self.delete_template(browseup_template1)
|
|
|
|
afteruploadprimarystoragelimit=self.getstoragelimits(11)
|
|
|
|
if afteruploadprimarystoragelimit!=(initialuploadprimarystoragelimit-tmpldetails[0].size):
|
|
self.fail("Secondary Storage Resource Count is not updated after deletion")
|
|
|
|
except Exception as e:
|
|
self.fail("Exception occurred : %s" % e)
|
|
return
|
|
|
|
# @attr(tags = ["advanced", "advancedns", "smoke", "basic"], required_hardware="false")
|
|
@attr(tags = ["TODO"], required_hardware="false")
|
|
def test_browser_upload_template_incomplete(self):
|
|
"""
|
|
Test browser based incomplete template upload, followed by SSVM destroy. Template should go to UploadAbandoned state and get cleaned up.
|
|
"""
|
|
try:
|
|
self.debug("========================= Test browser based incomplete template upload ========================")
|
|
|
|
#Only register template, without uploading
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
|
|
if 'kvm' in self.hypervisor.lower():
|
|
cmd.url = 'http://dl.openvm.eu/cloudstack/centos/x86_64/centos-7-kvm.qcow2.bz2'
|
|
if 'vmware' in self.hypervisor.lower():
|
|
cmd.url = 'http://dl.openvm.eu/cloudstack/centos/x86_64/centos-7-vmware.ova'
|
|
if 'xenserver' in self.hypervisor.lower():
|
|
cmd.url = 'http://dl.openvm.eu/cloudstack/centos/x86_64/centos-7-xen.vhd.bz2'
|
|
|
|
cmd.zoneid = self.zone.id
|
|
cmd.format = self.test_template.format
|
|
cmd.name=self.test_template.name+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=cmd.name
|
|
cmd.hypervisor=self.test_template.hypervisor
|
|
cmd.ostypeid=self.test_template.ostypeid
|
|
template_response=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
|
|
#Destroy SSVM, and wait for new one to start
|
|
self.destroy_ssvm()
|
|
|
|
#Verify that the template is cleaned up as part of sync-up during new SSVM start
|
|
list_template_response=Template.list(
|
|
self.apiclient,
|
|
id=template_response.id,
|
|
templatefilter="all",
|
|
zoneid=self.zone.id)
|
|
self.assertEqual(list_template_response, None, "Template is not cleaned up, some issue with template sync-up")
|
|
|
|
except Exception as e:
|
|
self.fail("Exceptione occurred : %s" % e)
|
|
return
|
|
|
|
@classmethod
|
|
def tearDownClass(self):
|
|
super(TestBrowseUploadVolume, self).tearDownClass()
|
|
|
|
def tearDown(self):
|
|
super(TestBrowseUploadVolume, self).tearDown()
|