apache/cloudstack
1
0
Fork 0
mirror of https://github.com/apache/cloudstack.git synced 2025-10-26 08:42:29 +01:00
Code Issues Packages Projects Releases Wiki Activity
cloudstack/test/integration/component/test_browse_volumes.py
John Bampton f090c77f41
misc: fix spelling (#7549) 
Co-authored-by: Stephan Krug <stekrug@icloud.com>
2023-11-02 09:23:53 +01:00

2637 lines
91 KiB
Python
Raw Blame History

# 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 os
import random
import string
import tempfile
import time
import unittest
import urllib.error
import urllib.parse
import urllib.request
import requests
from marvin.cloudstackAPI import *
from marvin.cloudstackTestCase import cloudstackTestCase
from marvin.codes import PASS, FAILED
from marvin.lib.base import *
from marvin.lib.common import *
from marvin.lib.utils import *
from nose.plugins.attrib import attr
_multiprocess_shared_ = True
class TestBrowseUploadVolume(cloudstackTestCase):
"""
Testing Browse Upload Volume Feature
"""
@classmethod
def setUpClass(cls):
cls.testClient = super(TestBrowseUploadVolume, cls).getClsTestClient()
cls.testdata = cls.testClient.getParsedTestDataConfig()
cls.apiclient = cls.testClient.getApiClient()
cls.hypervisor = cls.testClient.getHypervisorInfo()
cls._cleanup = []
cls.uploadvolumeformat = "VHD"
cls.storagetype = 'shared'
cls.globalurl = "http://url"
hosts = list_hosts(
cls.apiclient,
type="Routing"
)
if hosts is None:
raise unittest.SkipTest(
"There are no hypervisor's available.Check listhosts response")
for hypervisorhost in hosts:
if hypervisorhost.hypervisor == "XenServer":
cls.uploadvolumeformat = "VHD"
break
elif hypervisorhost.hypervisor == "VMware":
cls.uploadvolumeformat = "OVA"
break
elif hypervisorhost.hypervisor == "KVM":
cls.uploadvolumeformat = "QCOW2"
break
else:
break
cls.uploadurl = cls.testdata["configurableData"]["browser_upload_volume"][cls.uploadvolumeformat]["url"]
cls.volname = cls.testdata["configurableData"]["browser_upload_volume"][cls.uploadvolumeformat]["diskname"]
cls.md5sum = cls.testdata["configurableData"]["browser_upload_volume"][cls.uploadvolumeformat]["checksum"]
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
cls.domain = get_domain(cls.apiclient)
cls.pod = get_pod(cls.apiclient, cls.zone.id)
if cls.uploadvolumeformat == "QCOW2" or cls.uploadvolumeformat == "VHD":
cls.extuploadurl = cls.testdata["configurableData"]["browser_upload_volume"][cls.uploadvolumeformat]["url"]
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["configurableData"]["browser_upload_volume"]["browser_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 __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_volume(self, up_volid, volumestate):
config1 = Configurations.list(
self.apiclient,
name='upload.operation.timeout'
)
config2 = Configurations.list(
self.apiclient,
name='upload.monitoring.interval'
)
uploadtimeout = int(config1[0].value)
monitoringinterval = int(config2[0].value)
time.sleep((uploadtimeout * 60) + monitoringinterval)
list_volume_response = Volume.list(
self.apiclient,
id=up_volid
)
if list_volume_response is None:
self.debug("Volume got deleted after timeout")
return
self.assertEqual(
list_volume_response[0].state,
volumestate,
"Check volume state in ListVolumes"
)
return
def browse_upload_volume_with_projectid(self, projectid):
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.projectid = projectid
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(cmd)
signt = getuploadparamsresponse.signature
posturl = getuploadparamsresponse.postURL
metadata = getuploadparamsresponse.metadata
expiredata = getuploadparamsresponse.expires
url = self.uploadurl
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_volume(getuploadparamsresponse.id, 'Uploaded')
list_volume_response = Volume.list(
self.apiclient,
projectid=projectid
)
if list_volume_response[0].id == getuploadparamsresponse.id:
return (getuploadparamsresponse)
else:
self.fail("Volume is not listed with projectid")
def browse_upload_volume_with_out_zoneid(self):
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
success = False
try:
self.apiclient.getUploadParamsForVolume(cmd)
except Exception as ex:
if "Invalid Parameter" in str(ex):
success = True
self.assertEqual(
success,
True,
"Upload Volume - verify upload volume API request is handled without mandatory params - zoneid ")
return
def browse_upload_volume_with_out_format(self):
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
success = False
try:
self.apiclient.getUploadParamsForVolume(cmd)
except Exception as ex:
if "Invalid Parameter" in str(ex):
success = True
self.assertEqual(
success,
True,
"Upload Volume - verify upload volume API request is handled without mandatory params - format")
return
def browse_upload_volume(self):
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(cmd)
signt = getuploadparamsresponse.signature
posturl = getuploadparamsresponse.postURL
metadata = getuploadparamsresponse.metadata
expiredata = getuploadparamsresponse.expires
self.globalurl = getuploadparamsresponse.postURL
# url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
url = self.uploadurl
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_volume(getuploadparamsresponse.id, 'Uploaded')
return (getuploadparamsresponse)
def onlyupload(self):
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(cmd)
return (getuploadparamsresponse)
def invalidupload(self):
success = False
try:
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = "invalidformat"
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
self.apiclient.getUploadParamsForVolume(cmd)
except Exception as ex:
if "No enum constant com.cloud.storage.Storage.ImageFormat" in str(ex):
success = True
self.assertEqual(
success,
True,
"Verify - Upload volume with invalid format is handled")
return
def invalidposturl(self):
success = False
try:
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(cmd)
signt = getuploadparamsresponse.signature
posturl = "http://invalidposturl/2999834." + self.uploadvolumeformat
metadata = getuploadparamsresponse.metadata
expiredata = getuploadparamsresponse.expires
# url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
url = self.uploadurl
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)
self.debug(results.status_code)
if results.status_code != 200:
self.fail("Upload is not fine")
self.validate_uploaded_volume(getuploadparamsresponse.id, 'UploadedAbandoned')
except Exception as ex:
if "Max retries exceeded with url" in str(ex):
success = True
self.assertEqual(
success,
True,
"Verify - Tampered Post URL is handled")
return (getuploadparamsresponse)
def reuse_url(self):
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(cmd)
signt = getuploadparamsresponse.signature
posturl = self.globalurl
metadata = getuploadparamsresponse.metadata
expiredata = getuploadparamsresponse.expires
url = self.uploadurl
time.sleep(300)
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)
time.sleep(60)
if results.status_code == 200:
self.fail("Upload URL is allowed to reuse")
config = Configurations.list(
self.apiclient,
name='upload.operation.timeout'
)
uploadtimeout = int(config[0].value)
time.sleep(uploadtimeout * 60)
self.validate_uploaded_volume(getuploadparamsresponse.id, 'UploadAbandoned')
return
def validate_storage_cleanup(self, invalidpostvolume, cleanup_interval):
list_volume_response = Volume.list(
self.apiclient,
id=invalidpostvolume.id
)
self.assertNotEqual(
list_volume_response,
None,
"Check if volume exists in ListVolumes"
)
config1 = Configurations.list(
self.apiclient,
name='upload.operation.timeout'
)
config2 = Configurations.list(
self.apiclient,
name='upload.monitoring.interval'
)
uploadtimeout = int(config1[0].value)
monitorinterval = int(config2[0].value)
if cleanup_interval >= ((uploadtimeout * 60) + monitorinterval):
time.sleep(cleanup_interval)
else:
time.sleep(((uploadtimeout * 60) + monitorinterval))
list_volume_response = Volume.list(
self.apiclient,
id=invalidpostvolume.id
)
self.assertEqual(
list_volume_response,
None,
"Storage Cleanup - Verify UploadAbandoned volumes are deleted"
)
def validate_max_vol_size(self, up_vol, volumestate):
list_volume_response = Volume.list(
self.apiclient,
id=up_vol.id
)
self.assertNotEqual(
list_volume_response,
None,
"Check if volume exists in ListVolumes"
)
self.assertEqual(
list_volume_response[0].state,
volumestate,
"Check volume state in ListVolumes"
)
config = Configurations.list(
self.apiclient,
name='storage.max.volume.upload.size'
)
max_size = int(config[0].value)
self.debug(max_size)
self.debug(int(list_volume_response[0].size) / (1024 * 1024 * 1024))
if (int(list_volume_response[0].size) / (1024 * 1024 * 1024)) > max_size:
self.fail("Global Config storage.max.volume.upload.size is not considered with Browser Based Upload volumes")
def browse_upload_volume_with_md5(self):
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
cmd.checksum = self.md5sum
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(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.uploadurl
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)
if results.status_code != 200:
self.fail("Upload is not fine")
self.validate_uploaded_volume(getuploadparamsresponse.id, 'Uploaded')
return (getuploadparamsresponse)
def browse_upload_volume_with_invalid_md5(self):
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
cmd.checksum = "xxxxxxxx"
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(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.uploadurl
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")
self.validate_uploaded_volume(getuploadparamsresponse.id, 'Uploaded')
return (getuploadparamsresponse)
def validate_vm(self, vmdetails, vmstate):
time.sleep(120)
vm_response = VirtualMachine.list(
self.apiclient,
id=vmdetails.id,
)
self.assertEqual(
isinstance(vm_response, list),
True,
"Check list VM response for valid list"
)
# Verify VM response to check whether VM deployment was successful
self.assertNotEqual(
len(vm_response),
0,
"Check VMs available in List VMs response"
)
deployedvm = vm_response[0]
self.assertEqual(
deployedvm.state,
vmstate,
"Check the state of VM"
)
def deploy_vm(self):
virtual_machine = VirtualMachine.create(
self.apiclient,
self.testdata["virtual_machine"],
templateid=self.template.id,
zoneid=self.zone.id,
accountid=self.account.name,
domainid=self.account.domainid,
serviceofferingid=self.service_offering.id,
)
self.validate_vm(virtual_machine, '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 attach_deleted_volume(self, vmlist, volume):
success = False
try:
vmlist.attach_volume(
self.apiclient,
volume
)
except Exception as ex:
if "Please specify a volume with the valid type: DATADISK" in str(ex):
success = True
self.assertEqual(
success,
True,
"Attaching the Deleted Volume is handled appropriately not to get attached the deleted uploaded volume")
return
def reboot_vm(self, vmdetails):
vmdetails.reboot(self.apiclient)
self.validate_vm(vmdetails, 'Running')
def stop_vm(self, vmdetails):
vmdetails.stop(self.apiclient)
self.validate_vm(vmdetails, 'Stopped')
def start_vm(self, vmdetails):
vmdetails.start(self.apiclient)
self.validate_vm(vmdetails, '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
)
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):
# TODO: SIMENH: add another test the data on the restored VM.
"""Test recover Virtual Machine
"""
# cmd = recoverVirtualMachine.recoverVirtualMachineCmd()
cmd = restoreVirtualMachine.restoreVirtualMachineCmd()
cmd.virtualmachineid = vmdetails.id
self.apiclient.recoverVirtualMachine(cmd)
list_vm_response = VirtualMachine.list(
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 deletevolume_fail(self, volumeid):
"""Delete a Volume attached to a VM
"""
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = volumeid
success = False
try:
self.apiclient.deleteVolume(cmd)
except Exception as ex:
if "Please specify a volume that is not attached to any VM" in str(ex):
success = True
self.assertEqual(
success,
True,
"DeleteVolume - verify Ready State volume (attached to a VM) is handled appropriately not to get deleted ")
return
def delete_volume(self, volumeid):
"""Delete a Volume attached to a VM
"""
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = volumeid
self.apiclient.deleteVolume(cmd)
def download_volume(self, volumeid):
cmd = extractVolume.extractVolumeCmd()
cmd.id = volumeid
cmd.mode = "HTTP_DOWNLOAD"
cmd.zoneid = self.zone.id
extract_vol = self.apiclient.extractVolume(cmd)
try:
formatted_url = urllib.parse.unquote_plus(extract_vol.url)
self.debug("Attempting to download volume at url %s" % formatted_url)
response = urllib.request.urlopen(formatted_url)
self.debug("response from volume url %s" % response.getcode())
fd, path = tempfile.mkstemp()
self.debug("Saving volume %s to path %s" % (volumeid, path))
os.close(fd)
with open(path, 'wb') as fd:
fd.write(response.read())
self.debug("Saved volume successfully")
except Exception:
self.fail(
"Extract Volume Failed with invalid URL %s (vol id: %s)" \
% (extract_vol.url, volumeid)
)
def resize_fail(self, volumeid):
cmd = resizeVolume.resizeVolumeCmd()
cmd.id = volumeid
cmd.diskofferingid = self.disk_offering.id
success = False
try:
self.apiclient.resizeVolume(cmd)
except Exception as ex:
if "Volume should be in ready or allocated state before attempting a resize" in str(ex):
success = True
self.assertEqual(
success,
True,
"ResizeVolume - verify Uploaded State volume is handled appropriately")
def resize_volume(self, volumeid):
"""Test resize a volume"""
self.testdata["configurableData"]["browser_upload_volume"]["browser_resized_disk_offering"]["disksize"] = 20
disk_offering_20_GB = DiskOffering.create(
self.apiclient,
self.testdata["configurableData"]["browser_upload_volume"]["browser_resized_disk_offering"]
)
self.cleanup.append(disk_offering_20_GB)
cmd = resizeVolume.resizeVolumeCmd()
cmd.id = volumeid
cmd.diskofferingid = disk_offering_20_GB.id
self.apiclient.resizeVolume(cmd)
count = 0
success = False
while count < 3:
list_volume_response = Volume.list(
self.apiclient,
id=volumeid,
type='DATADISK'
)
for vol in list_volume_response:
if vol.id == volumeid and int(vol.size) == (int(disk_offering_20_GB.disksize) * (1024 ** 3)) and vol.state == 'Ready':
success = True
if success:
break
else:
time.sleep(10)
count += 1
self.assertEqual(
success,
True,
"Check if the data volume resized appropriately"
)
return
def destroy_vm(self, vmdetails):
success = False
vmdetails.delete(self.apiclient, expunge=False)
try:
list_vm_response1 = VirtualMachine.list(
self.apiclient,
id=vmdetails.id
)
except Exception as ex:
if "Unable to find a virtual machine with specified vmId" in str(ex):
success = True
if success == "True":
self.debug("VM is already expunged")
return
list_vm_response1 = VirtualMachine.list(
self.apiclient,
id=vmdetails.id
)
if list_vm_response1 is None:
self.debug("VM already expunged")
return
if list_vm_response1[0].state == "Expunging":
self.debug("VM already getting expunged")
return
list_vm_response = VirtualMachine.list(
self.apiclient,
id=vmdetails.id
)
if list_vm_response is None:
self.debug("VM already expunged")
return
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):
list_vm_response1 = VirtualMachine.list(
self.apiclient,
id=vmdetails.id
)
if list_vm_response1 is None:
self.debug("VM already expunged")
return
cmd = recoverVirtualMachine.recoverVirtualMachineCmd()
cmd.id = vmdetails.id
self.apiclient.recoverVirtualMachine(cmd)
list_vm_response1 = VirtualMachine.list(
self.apiclient,
id=vmdetails.id
)
if list_vm_response1 is None:
self.debug("VM already expunged")
return
list_vm_response1 = VirtualMachine.list(
self.apiclient,
id=vmdetails.id
)
if list_vm_response1[0].state == "Expunging":
self.debug("VM already getting expunged")
return
list_vm_response = VirtualMachine.list(
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 = VirtualMachine.list(
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
def volume_snapshot(self, volumedetails):
"""
@summary: Test to verify creation of snapshot from volume
and creation of template, volume from snapshot
"""
if self.uploadvolumeformat == "QCOW2":
config = Configurations.list(
self.apiclient,
name='kvm.snapshot.enabled'
)
kvmsnapshotenabled = config[0].value
if kvmsnapshotenabled == "false":
self.fail("Please enable kvm.snapshot.enable global config")
list_volumes = Volume.list(
self.apiclient,
id=volumedetails.id
)
# Creating Snapshot from volume
snapshot_created = Snapshot.create(
self.apiclient,
volumedetails.id,
)
self.assertIsNotNone(snapshot_created, "Snapshot not created")
self.cleanup.append(snapshot_created)
# Creating expected and actual values dictionaries
expected_dict = {
"id": volumedetails.id,
"intervaltype": "MANUAL",
"snapshottype": "MANUAL",
"volumetype": list_volumes[0].type,
"domain": self.domain.id
}
actual_dict = {
"id": snapshot_created.volumeid,
"intervaltype": snapshot_created.intervaltype,
"snapshottype": snapshot_created.snapshottype,
"volumetype": snapshot_created.volumetype,
"domain": snapshot_created.domainid,
}
status = self.__verify_values(
expected_dict,
actual_dict
)
self.assertEqual(
True,
status,
"Snapshot created from Volume details are not as expected"
)
return (snapshot_created)
def volume_snapshot_volume(self, snapshot_created):
# Creating Volume from snapshot
cmd = createVolume.createVolumeCmd()
cmd.name = "-".join([self.testdata["volume"]
["diskname"], random_gen()])
cmd.snapshotid = snapshot_created.id
volume_from_snapshot = Volume(
self.apiclient.createVolume(cmd).__dict__)
self.assertIsNotNone(
volume_from_snapshot,
"Volume creation failed from snapshot"
)
return
def volume_snapshot_template(self, snapshot_created):
# Creating Template from Snapshot
list_templates_before = Template.list(
self.apiclient,
templatefilter='self')
if list_templates_before is None:
templates_before_size = 0
else:
templates_before_size = len(list_templates_before)
cmd = createTemplate.createTemplateCmd()
cmd.name = self.testdata["ostype"]
cmd.displaytext = self.testdata["ostype"]
cmd.ostypeid = self.template.ostypeid
cmd.snapshotid = snapshot_created.id
cmd.ispublic = False
cmd.passwordenabled = False
template_from_snapshot = Template(
self.apiclient.createTemplate(cmd).__dict__)
self.assertIsNotNone(
template_from_snapshot,
"Template creation failed from snapshot"
)
self.cleanup.append(template_from_snapshot)
# Creating expected and actual values dictionaries
expected_dict = {
"name": self.testdata["ostype"],
"ostypeid": self.template.ostypeid,
"type": "USER",
"zone": self.zone.id,
"passwordenabled": False,
"ispublic": False,
"size": self.disk_offering.disksize
}
actual_dict = {
"name": template_from_snapshot.name,
"ostypeid": template_from_snapshot.ostypeid,
"type": template_from_snapshot.templatetype,
"zone": template_from_snapshot.zoneid,
"passwordenabled": template_from_snapshot.passwordenabled,
"ispublic": template_from_snapshot.ispublic,
"size": template_from_snapshot.size / (1024 * 1024 * 1024)
}
status = self.__verify_values(
expected_dict,
actual_dict
)
# self.assertEqual(
# True,
# status,
# "Template created from Snapshot details are not as expected"
# )
list_templates_after = Template.list(
self.apiclient,
templatefilter='self')
self.assertEqual(
templates_before_size + 1,
len(list_templates_after),
"Template creation failed from snapshot"
)
return
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 uploadvol(self, getuploadparamsresponse):
signt = getuploadparamsresponse.signature
posturl = getuploadparamsresponse.postURL
metadata = getuploadparamsresponse.metadata
expiredata = getuploadparamsresponse.expires
success = False
url = self.uploadurl
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)
list_volume_response = Volume.list(
self.apiclient,
id=getuploadparamsresponse.id
)
self.debug("======================Before SSVM Reboot==================")
self.reboot_ssvm()
self.debug("======================After SSVM Reboot==================")
config = Configurations.list(
self.apiclient,
name='upload.operation.timeout'
)
uploadtimeout = int(config[0].value)
time.sleep(uploadtimeout * 60)
self.validate_uploaded_volume(getuploadparamsresponse.id, 'UploadAbandoned')
return ()
def uploadvolwithssvmreboot(self, getuploadparamsresponse):
signt = getuploadparamsresponse.signature
posturl = getuploadparamsresponse.postURL
metadata = getuploadparamsresponse.metadata
expiredata = getuploadparamsresponse.expires
self.debug("======================Before SSVM Reboot==================")
list_volume_response = Volume.list(
self.apiclient,
id=getuploadparamsresponse.id
)
self.debug(list_volume_response[0])
self.reboot_ssvm()
success = False
url = self.uploadurl
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)
list_volume_response = Volume.list(
self.apiclient,
id=getuploadparamsresponse.id
)
self.debug("======================Upload After SSVM Reboot==================")
self.debug(list_volume_response[0])
self.validate_uploaded_volume(getuploadparamsresponse.id, 'Uploaded')
return ()
def uploadwithcustomoffering(self):
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
cmd.diskofferingid = self.disk_offering.id
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(cmd)
signt = getuploadparamsresponse.signature
posturl = getuploadparamsresponse.postURL
metadata = getuploadparamsresponse.metadata
expiredata = getuploadparamsresponse.expires
self.globalurl = getuploadparamsresponse.postURL
# url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
url = self.uploadurl
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_volume(getuploadparamsresponse.id, 'Uploaded')
def uploadwithimagestoreid(self):
sscmd = listImageStores.listImageStoresCmd()
sscmd.zoneid = self.zone.id
sscmdresponse = self.apiclient.listImageStores(sscmd)
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
cmd.imagestoreuuid = sscmdresponse[0].id
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(cmd)
signt = getuploadparamsresponse.signature
posturl = getuploadparamsresponse.postURL
metadata = getuploadparamsresponse.metadata
expiredata = getuploadparamsresponse.expires
self.globalurl = getuploadparamsresponse.postURL
# url = 'http://10.147.28.7/templates/rajani-thin-volume.vhd'
url = self.uploadurl
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_volume(getuploadparamsresponse.id, 'Uploaded')
def uploadwithsamedisplaytext(self, voldetails):
list_volume_response = Volume.list(
self.apiclient,
id=voldetails.id
)
success = True
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = list_volume_response[0].name
cmd.account = self.account.name
cmd.domainid = self.domain.id
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(cmd)
list_volume_response1 = Volume.list(
self.apiclient,
id=getuploadparamsresponse.id
)
if list_volume_response1[0].name == voldetails.name:
success = False
self.assertEqual(
success,
False,
"Verify: Upload Multiple volumes with same name is handled")
return
def uploadvolwithmultissvm(self):
ssvmhosts = list_hosts(
self.apiclient,
type="SecondaryStorageVM"
)
self.debug("Total SSVMs are:")
self.debug(len(ssvmhosts))
if len(ssvmhosts) == 1:
return (1)
config = Configurations.list(
self.apiclient,
name='secstorage.session.max'
)
multissvmvalue = int(config[0].value)
if multissvmvalue != 1:
return (0)
browseup_vol = self.browse_upload_volume()
vm1details = self.deploy_vm()
self.attach_volume(vm1details, browseup_vol.id)
self.vmoperations(vm1details)
self.destroy_vm(vm1details)
self.detach_volume(vm1details, browseup_vol.id)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = browseup_vol.id
self.apiclient.deleteVolume(cmd)
return (2)
def uploadwithextendedfileextentions(self):
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
cmd.diskofferingid = self.disk_offering.id
getuploadparamsresponse = self.apiclient.getUploadParamsForVolume(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.extuploadurl
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_volume(getuploadparamsresponse.id, 'Uploaded')
def posturlwithdeletedvolume(self, getuploadparamsresponse):
signt = getuploadparamsresponse.signature
posturl = getuploadparamsresponse.postURL
metadata = getuploadparamsresponse.metadata
expiredata = getuploadparamsresponse.expires
self.validate_uploaded_volume(getuploadparamsresponse.id, 'UploadAbandoned')
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = getuploadparamsresponse.id
self.apiclient.delete_volume(cmd)
success = False
url = self.extuploadurl
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:
return ("FAIL")
return ("PASS")
def volume_migration(self, browseup_vol, vm1details):
pools = StoragePool.list(
self.apiclient,
zoneid=self.zone.id
)
if not pools:
self.skipTest(
"No suitable storage pools found for volume migration.\
Skipping")
self.assertEqual(
validateList(pools)[0],
PASS,
"invalid pool response from findStoragePoolsForMigration")
pool = pools[0]
try:
if vm1details is None:
Volume.migrate(
self.apiclient,
volumeid=browseup_vol.id,
storageid=pool.id,
livemigrate='false'
)
else:
Volume.migrate(
self.apiclient,
volumeid=browseup_vol.id,
storageid=pool.id,
livemigrate='true'
)
except Exception as e:
self.fail("Volume migration failed with error %s" % e)
return
def getvolumelimts(self):
totalresourcelist = Account.list(
self.apiclient,
id=self.account.id
)
totalvolumes = totalresourcelist[0].volumetotal
return (totalvolumes)
def getstoragelimts(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)
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_01_Browser_volume_Life_cycle_tpath(self):
"""
Test Browser_volume_Life_cycle - This includes upload volume,attach to a VM, write data ,Stop ,Start, Reboot,Reset of a VM, detach,attach back to the VM, delete volumes
"""
try:
self.debug("========================= Test 1: Upload Browser based volume and validate ========================= ")
browseup_vol = self.browse_upload_volume()
self.debug("========================= Test 2: Deploy a VM , Attach Uploaded Browser based volume and validate VM Operations========================= ")
vm1details = self.deploy_vm()
self.attach_volume(vm1details, browseup_vol.id)
self.vmoperations(vm1details)
self.debug("========================= Test 3: Restore VM with Uploaded volume attached========================= ")
self.restore_vm(vm1details)
self.debug("========================= Test 4: Detach Uploaded volume and validation of VM operations after detach========================= ")
self.detach_volume(vm1details, browseup_vol.id)
self.vmoperations(vm1details)
self.destroy_vm(vm1details)
self.debug("========================= Test 5: Deploy New VM,Attach the detached Uploaded volume and validate VM operations after attach========================= ")
vm2details = self.deploy_vm()
self.attach_volume(vm2details, browseup_vol.id)
self.vmoperations(vm2details)
self.debug("========================= Test 6: Detach Uploaded volume and resize detached uploaded volume========================= ")
self.detach_volume(vm2details, browseup_vol.id)
if self.hypervisor.lower() != "hyperv":
self.resize_volume(browseup_vol.id)
self.debug("========================= Test 7: Attach resized uploaded volume and validate VM operations========================= ")
self.attach_volume(vm2details, browseup_vol.id)
self.vmoperations(vm2details)
self.detach_volume(vm2details, browseup_vol.id)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = browseup_vol.id
self.apiclient.deleteVolume(cmd)
self.debug("========================= Test 8: Try resizing uploaded state volume and validate the error scenario========================= ")
browseup_vol2 = self.browse_upload_volume()
self.resize_fail(browseup_vol2.id)
self.debug("========================= Test 9: Attach multiple uploaded volumes to a VM and validate VM operations========================= ")
browseup_vol3 = self.browse_upload_volume()
self.attach_volume(vm2details, browseup_vol2.id)
self.attach_volume(vm2details, browseup_vol3.id)
self.vmoperations(vm2details)
self.debug("========================= Test 10: Detach and delete uploaded volume========================= ")
self.detach_volume(vm2details, browseup_vol2.id)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = browseup_vol2.id
self.apiclient.deleteVolume(cmd)
self.debug("========================= Test 11: Detach and download uploaded volume========================= ")
self.detach_volume(vm2details, browseup_vol3.id)
self.download_volume(browseup_vol3.id)
self.debug("========================= Test 12: Delete detached uploaded volume========================= ")
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = browseup_vol3.id
self.apiclient.deleteVolume(cmd)
self.debug("========================= Deletion of UnUsed VM's after test is complete========================= ")
self.expunge_vm(vm2details)
self.debug("========================= Test 13: Delete Uploaded State volume========================= ")
browseup_vol4 = self.browse_upload_volume()
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = browseup_vol4.id
self.apiclient.deleteVolume(cmd)
self.debug("========================= Test 14: Destroy VM which has Uploaded volumes attached========================= ")
vm4details = self.deploy_vm()
newvolumetodestroy_VM = self.browse_upload_volume()
self.attach_volume(vm4details, newvolumetodestroy_VM.id)
self.destroy_vm(vm4details)
self.debug("========================= Test 15: Recover destroyed VM which has Uploaded volumes attached========================= ")
self.recover_destroyed_vm(vm4details)
self.expunge_vm(vm4details)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = newvolumetodestroy_VM.id
self.apiclient.deleteVolume(cmd)
self.debug(
"========================= Test 16: Delete attached Uploaded volume which is in ready state and it should not be allowed to delete========================= ")
vm5details = self.deploy_vm()
browseup_vol5 = self.browse_upload_volume()
self.attach_volume(vm5details, browseup_vol5.id)
self.deletevolume_fail(browseup_vol5.id)
self.debug("========================= Test 17: Create Volume Backup Snapshot uploaded volume attached to the VM========================= ")
vm6details = self.deploy_vm()
browseup_vol6 = self.browse_upload_volume()
self.attach_volume(vm6details, browseup_vol6.id)
snapshotdetails = self.volume_snapshot(browseup_vol6)
self.debug("========================= Test 18: Create Volume from Backup Snapshot of attached uploaded volume========================= ")
self.volume_snapshot_volume(snapshotdetails)
self.debug("========================= Test 19: Create template from Backup Snapshot of attached uploaded volume========================= ")
self.volume_snapshot_template(snapshotdetails)
self.detach_volume(vm6details, browseup_vol6.id)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = browseup_vol6.id
self.apiclient.deleteVolume(cmd)
self.expunge_vm(vm6details)
self.debug("========================= Test 20: Upload Browser based volume with checksum and validate ========================= ")
browseup_vol_withchecksum = self.browse_upload_volume_with_md5()
self.debug("========================= Test 21: Deploy a VM , Attach Uploaded Browser based volume with checksum and validate VM Operations========================= ")
vm7details = self.deploy_vm()
self.attach_volume(vm7details, browseup_vol_withchecksum.id)
self.debug("========================= Test 22: Detach Uploaded volume with checksum and validation of VM operations after detach========================= ")
self.detach_volume(vm7details, browseup_vol_withchecksum.id)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = browseup_vol_withchecksum.id
self.apiclient.deleteVolume(cmd)
self.vmoperations(vm7details)
self.expunge_vm(vm7details)
except Exception as e:
self.fail("Exception occurred : %s" % e)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_02_SSVM_Life_Cycle_With_Browser_Volume_TPath(self):
"""
Test SSVM_Life_Cycle_With_Browser_Volume_TPath - This includes SSVM life cycle followed by Browser volume upload operations
"""
try:
self.debug("========================= Test 23: Stop and Start SSVM and Perform Browser based volume validations ========================= ")
self.stop_ssvm()
ssvm1browseup_vol = self.browse_upload_volume()
ssvm1vm1details = self.deploy_vm()
self.attach_volume(ssvm1vm1details, ssvm1browseup_vol.id)
self.vmoperations(ssvm1vm1details)
self.detach_volume(ssvm1vm1details, ssvm1browseup_vol.id)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = ssvm1browseup_vol.id
self.apiclient.deleteVolume(cmd)
self.expunge_vm(ssvm1vm1details)
self.debug("========================= Test 24: Reboot SSVM and Perform Browser based volume validations ========================= ")
self.reboot_ssvm()
ssvm2browseup_vol = self.browse_upload_volume()
ssvm2vm1details = self.deploy_vm()
self.attach_volume(ssvm2vm1details, ssvm2browseup_vol.id)
self.vmoperations(ssvm2vm1details)
self.detach_volume(ssvm2vm1details, ssvm2browseup_vol.id)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = ssvm2browseup_vol.id
self.apiclient.deleteVolume(cmd)
self.expunge_vm(ssvm2vm1details)
self.debug("========================= Test 25: Reboot SSVM and Perform Browser based volume validations ========================= ")
self.destroy_ssvm()
ssvm3browseup_vol = self.browse_upload_volume()
ssvm3vm1details = self.deploy_vm()
self.attach_volume(ssvm3vm1details, ssvm3browseup_vol.id)
self.vmoperations(ssvm3vm1details)
self.detach_volume(ssvm3vm1details, ssvm3browseup_vol.id)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = ssvm3browseup_vol.id
self.apiclient.deleteVolume(cmd)
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_Upload_Volume_Global_Config_TPath(self):
"""
Test Browser_Upload_Volume_Global_Config limits
"""
try:
self.debug("========================= Test 26 Validate Storage.max.upload.size ========================= ")
globalconfig_browse_up_vol = self.browse_upload_volume()
self.validate_max_vol_size(globalconfig_browse_up_vol, "Uploaded")
except Exception as e:
self.fail("Exception occurred : %s" % e)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_04_Browser_Upload_Volume_Negative_Scenarios_TPath(self):
"""
Test Browser_Upload_Volume_Negative_Scenarios
"""
try:
self.debug("========================= Test 27 Reuse the POST URL after expiry time========================= ")
reuse_browse_up_vol = self.browse_upload_volume()
self.reuse_url()
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = reuse_browse_up_vol.id
self.apiclient.deleteVolume(cmd)
self.debug("========================= Test 28 Reboot SSVM before upload is completed=========================")
browse_up_vol = self.onlyupload()
self.uploadvol(browse_up_vol)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = browse_up_vol.id
self.apiclient.deleteVolume(cmd)
self.debug("========================= Test 29 Reboot SSVM after getting the upload volume params and before initiating the upload=========================")
browse_up_vol = self.onlyupload()
self.uploadvolwithssvmreboot(browse_up_vol)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = reuse_browse_up_vol.id
self.apiclient.deleteVolume(cmd)
self.debug("========================= Test 30 Attach Deleted Volume=========================")
deleted_browse_up_vol = self.browse_upload_volume()
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = deleted_browse_up_vol.id
self.apiclient.deleteVolume(cmd)
deletedvm1details = self.deploy_vm()
self.attach_deleted_volume(deletedvm1details, deleted_browse_up_vol)
self.debug("========================= Test 31 Upload Volume with Invalid Format=========================")
self.invalidupload()
self.debug("========================= Test 32 Upload Mutliple Volumes with same display text=========================")
samedisplaytext_browse_up_vol = self.browse_upload_volume()
self.uploadwithsamedisplaytext(samedisplaytext_browse_up_vol)
self.debug("========================= Test 33 Upload Volume with custom offering id=========================")
self.uploadwithcustomoffering()
except Exception as e:
self.fail("Exception occurred : %s" % e)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_05_Browser_Upload_Volume_MultiSSVM_Scenarios_TPath(self):
"""
Test Browser_Upload_Volume_MultiSSVM_Scenarios
"""
try:
self.debug("========================= Test 34 Upload volume with Multiple SSVM=========================")
testresult = self.uploadvolwithmultissvm()
if testresult == 0:
raise unittest.SkipTest("secstorage.session.max global config is not set to 1 which means Multiple SSVM's are not present")
elif testresult == 1:
raise unittest.SkipTest("only one SSVM is present")
except Exception as e:
self.fail("Exception occurred : %s" % e)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_06_Browser_Upload_Volume_with_extended_file_extensions(self):
"""
Test Browser_Upload_Volume_with_extended_file_extensions
"""
try:
self.debug("========================= Test 35 Upload volume with extended file extensions=========================")
if self.uploadvolumeformat == "OVA":
raise unittest.SkipTest("This test is need not be executed on VMWARE")
self.uploadwithextendedfileextentions()
except Exception as e:
self.fail("Exception occurred : %s" % e)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_07_Browser_Upload_Volume_Storage_Cleanup_Config_Validation(self):
"""
Test Browser_Upload_Volume_Storage_Cleanup_Config_Validation
"""
self.debug("========================= Test 36 Validate storage.cleanup.enabled and storage.cleanup.interval ========================= ")
config1 = Configurations.list(
self.apiclient,
name='storage.cleanup.enabled'
)
config2 = Configurations.list(
self.apiclient,
name='storage.cleanup.interval'
)
cleanup_enabled = config1[0].value
cleanup_interval = int(config2[0].value)
if cleanup_enabled == "false":
raise unittest.SkipTest("storage.cleanup.enabled is not set to true")
if cleanup_interval > 600:
raise unittest.SkipTest("storage.cleanup.interval is set to wait for more than 10 mins before cleanup. Please reduce the interval to less than 10 mins")
invaliduploadvolume = self.invalidposturl()
self.validate_storage_cleanup(invaliduploadvolume, cleanup_interval)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_08_Browser_Upload_Volume_TamperedPostURL(self):
"""
Test Browser_Upload_Volume_Negative_Scenarios
"""
try:
self.debug("========================= Test 37 Upload Volume with tampered post URL=========================")
invaliduploadvolume = self.invalidposturl()
except Exception as e:
self.fail("Exception occurred : %s" % e)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_09_Browser_Upload_Volume_PostURL_with_Deleted_Uploadvolume_Details(self):
"""
Test Browser_Upload_Volume_PostURL_with_Deleted_Uploadvolume_Details
"""
self.debug("========================= Test 38 PostURL_with_Deleted_Upload_Abondaned volume details=========================")
browse_up_vol = self.onlyupload()
res = self.posturlwithdeletedvolume(browse_up_vol)
if res == "FAIL":
self.fail("Verify - PostURL_with_Deleted_Uploadvolume_Details ")
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_10_Browser_Upload_Volume_API_with_imagepoolid(self):
"""
Test Browser_Upload_Volume_API_with_imagepoolid
"""
self.debug("========================= Test 39 Test Browser_Upload_Volume_API_with_imagepoolid=========================")
self.uploadwithimagestoreid()
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_11_migrate_upload_volume(self):
"""
Test Browser_Upload_Volume_migrate_upload_volume
"""
self.debug("========================= Test 40 Test Browser_Upload_Volume_Migration=========================")
browseup_vol = self.browse_upload_volume()
vm1details = self.deploy_vm()
self.attach_volume(vm1details, browseup_vol.id)
self.volume_migration(browseup_vol, vm1details)
self.debug("========================= Test 41 Test VM Operations after Browser_Upload_Volume_Migration=========================")
self.vmoperations(vm1details)
self.debug("========================= Test 42 Detach Browser_Upload_Volume after Migration and attach to a new VM=========================")
self.detach_volume(vm1details, browseup_vol.id)
vm2details = self.deploy_vm()
self.attach_volume(vm2details, browseup_vol.id)
self.vmoperations(vm2details)
self.debug("========================= Test 43 Detach Browser_Upload_Volume and Migrate to another storage=========================")
self.detach_volume(vm2details, browseup_vol.id)
self.volume_migration(browseup_vol, "None")
self.debug("========================= Test 44 Attach detached Browser_Upload_Volume after Migration =========================")
self.attach_volume(vm2details, browseup_vol.id)
self.vmoperations(vm2details)
self.debug("========================= Test 45 Detach ,Resize,Attach Browser_Upload_Volume after Migration =========================")
self.detach_volume(vm2details, browseup_vol.id)
if self.hypervisor.lower() != "hyperv":
self.resize_volume(browseup_vol.id)
self.attach_volume(vm2details, browseup_vol.id)
self.vmoperations(vm2details)
self.detach_volume(vm2details, browseup_vol.id)
self.cleanup.append(browseup_vol)
self.cleanup.append(vm2details)
self.cleanup.append(vm1details)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_12_Browser_Upload_Volume_with_all_API_parameters(self):
"""
Test Browser_Upload_Volumewith all API parameters
"""
try:
self.debug("========================= Test 46 & 47 Upload volume with account name and domainid========================")
browseup_vol1 = self.browse_upload_volume()
self.debug("========================= Test 48 Upload volume with projectid========================")
browseup_vol2 = self.browse_upload_volume_with_projectid(self.project.id)
self.debug("========================= Test 49 Upload volume with out mandatory param zone id ========================")
browseup_vol2 = self.browse_upload_volume_with_out_zoneid()
self.debug("========================= Test 50 Upload volume with out mandatory param format ========================")
browseup_vol3 = self.browse_upload_volume_with_out_format()
except Exception as e:
self.fail("Exception occurred : %s" % e)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_13_Browser_Upload_Volume_volume_resource_limits(self):
"""
Test Browser_Upload_Volume Volume Resource limits
"""
try:
self.debug("========================= Test 51 Upload volume and verify volume limits========================")
initialvolumelimit = self.getvolumelimts()
browseup_vol1 = self.browse_upload_volume()
afteruploadvolumelimit = self.getvolumelimts()
if int(afteruploadvolumelimit) != (int(initialvolumelimit) + 1):
self.fail("Volume Resource Count is not updated")
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = deleted_browse_up_vol1.id
self.apiclient.deleteVolume(cmd)
except Exception as e:
self.fail("Exception occurred : %s" % e)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_14_Browser_Upload_Volume_secondary_storage_resource_limits(self):
"""
Test Browser_Upload_Volume Secondary Storage Resource limits
"""
try:
self.debug("========================= Test 52 Upload volume and verify secondary storage limits========================")
initialsecondarystoragelimit = self.getstoragelimts(11)
browseup_vol1 = self.browse_upload_volume()
volumedetails = Volume.list(
self.apiclient,
id=browseup_vol1.id)
afteruploadsecondarystoragelimit = self.getstoragelimts(11)
if afteruploadsecondarystoragelimit != (initialsecondarystoragelimit + volumedetails[0].size):
self.fail("Secondary Storage Resource Count is not updated")
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = deleted_browse_up_vol1.id
self.apiclient.deleteVolume(cmd)
except Exception as e:
self.fail("Exception occurred : %s" % e)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_15_Browser_Upload_Volume_primary_storage_resource_limits(self):
"""
Test Browser_Upload_Volume Primary Storage Resource limits
"""
try:
self.debug("========================= Test 53 Attach Upload volume and verify primary storage limits========================")
initialprimarystoragelimit = self.getstoragelimts(10)
browseup_vol1 = self.browse_upload_volume()
volumedetails = Volume.list(
self.apiclient,
id=browseup_vol1.id)
afteruploadprimarystoragelimit = self.getstoragelimts(10)
if afteruploadprimarystoragelimit != (initialprimarystoragelimit + volumedetails[0].size):
self.fail("Primary Storage Resource Count is not updated")
except Exception as e:
self.fail("Exception occurred : %s" % e)
return
@attr(tags=["advanced", "advancedns", "smoke", "basic"], required_hardware="true")
def test_16_Browser_Upload_volume_resource_limits_after_deletion(self):
"""
Test Browser_Upload_Volume resource_limits_after_deletion
"""
try:
self.debug("========================= Test 54 Delete Upload volume and verify volume limits========================")
browseup_vol1 = self.browse_upload_volume()
initialvolumelimit = self.getvolumelimts()
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = browseup_vol1.id
self.apiclient.deleteVolume(cmd)
aftervolumelimit = self.getvolumelimts()
if aftervolumelimit != (initialvolumelimit - 1):
self.fail("Volume 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="true")
def test_17_Browser_Upload_Volume_secondary_storage_resource_limits_after_deletion(self):
"""
Test Browser_Upload_Volume secondary_storage_resource_limits_after_deletion
"""
try:
self.debug("========================= Test 55 Delete Upload volume and secondary storage limits========================")
browseup_vol1 = self.browse_upload_volume()
volumedetails = Volume.list(
self.apiclient,
id=browseup_vol1.id)
initialuploadsecondarystoragelimit = self.getstoragelimts(11)
cmd = deleteVolume.deleteVolumeCmd()
cmd.id = browseup_vol1.id
self.apiclient.deleteVolume(cmd)
afteruploadsecondarystoragelimit = self.getstoragelimts(11)
if afteruploadsecondarystoragelimit != (initialuploadsecondarystoragelimit - volumedetails[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")
def test_browser_upload_volume_incomplete(self):
"""
Test browser based incomplete volume upload, followed by SSVM destroy. Volume should go to UploadAbandoned/Error state and get cleaned up.
"""
try:
self.debug("========================= Test browser based incomplete volume upload ========================")
# Only register volume, without uploading
cmd = getUploadParamsForVolume.getUploadParamsForVolumeCmd()
cmd.zoneid = self.zone.id
cmd.format = self.uploadvolumeformat
cmd.name = self.volname + self.account.name + (random.choice(string.ascii_uppercase))
cmd.account = self.account.name
cmd.domainid = self.domain.id
upload_volume_response = self.apiclient.getUploadParamsForVolume(cmd)
# Destroy SSVM, and wait for new one to start
self.destroy_ssvm()
# Verify that the volume is cleaned up as part of sync-up during new SSVM start
self.validate_uploaded_volume(upload_volume_response.id, 'UploadAbandoned')
except Exception as e:
self.fail("Exceptione occurred : %s" % e)
return
@classmethod
def tearDownClass(self):
super(TestBrowseUploadVolume, self).tearDownClass()
def setup(self):
cleanup = []
def tearDown(self):
super(TestBrowseUploadVolume, self).tearDown()
Reference in New Issue View Git Blame Copy Permalink