mirror of
https://github.com/apache/cloudstack.git
synced 2025-11-04 00:02:37 +01:00
1685 lines
61 KiB
Python
1685 lines
61 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, unittest
|
|
from marvin.cloudstackAPI import *
|
|
from marvin.lib.utils import *
|
|
from marvin.lib.base import *
|
|
from marvin.lib.common import *
|
|
from marvin.codes import PASS,FAILED,SUCCESS,XEN_SERVER
|
|
|
|
from marvin.sshClient import SshClient
|
|
|
|
import requests
|
|
|
|
import wget
|
|
|
|
import random
|
|
|
|
import string
|
|
|
|
import telnetlib
|
|
import os
|
|
import urllib
|
|
import time
|
|
import tempfile
|
|
_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.cleanup = []
|
|
cls.uploadtemplateformat="VHD"
|
|
cls.storagetype = 'shared'
|
|
|
|
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.uploadtemplateformat="VHD"
|
|
break
|
|
elif hypervisorhost.hypervisor== "VMware":
|
|
cls.uploadtemplateformat="OVA"
|
|
break
|
|
elif hypervisorhost.hypervisor=="KVM":
|
|
cls.uploadtemplateformat="QCOW2"
|
|
break
|
|
else:
|
|
break
|
|
cls.uploadurl=cls.testdata["configurableData"]["browser_upload_template"][cls.uploadtemplateformat]["url"]
|
|
cls.templatename=cls.testdata["configurableData"]["browser_upload_template"][cls.uploadtemplateformat]["templatename"]
|
|
cls.md5sum=cls.testdata["configurableData"]["browser_upload_template"][cls.uploadtemplateformat]["checksum"]
|
|
cls.templatedisplaytext=cls.testdata["configurableData"]["browser_upload_template"][cls.uploadtemplateformat]["displaytext"]
|
|
cls.templatehypervisor=cls.testdata["configurableData"]["browser_upload_template"][cls.uploadtemplateformat]["hypervisor"]
|
|
cls.templateostypeid=cls.testdata["configurableData"]["browser_upload_template"][cls.uploadtemplateformat]["ostypeid"]
|
|
cls.zone = get_zone(cls.apiclient, cls.testClient.getZoneForTests())
|
|
cls.domain = get_domain(cls.apiclient)
|
|
cls.pod = get_pod(cls.apiclient, cls.zone.id)
|
|
|
|
cls.account = Account.create(
|
|
cls.apiclient,
|
|
cls.testdata["account"],
|
|
domainid=cls.domain.id
|
|
)
|
|
|
|
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.disk_offering = DiskOffering.create(
|
|
cls.apiclient,
|
|
cls.testdata["configurableData"]["browser_upload_volume"]["browser_resized_disk_offering"],
|
|
custom=True
|
|
)
|
|
cls.project = Project.create(
|
|
cls.apiclient,
|
|
cls.testdata["project"],
|
|
account=cls.account.name,
|
|
domainid=cls.account.domainid
|
|
)
|
|
cls._cleanup = [
|
|
cls.project,
|
|
cls.account,
|
|
cls.service_offering,
|
|
cls.disk_offering
|
|
]
|
|
|
|
|
|
def __verify_values(self, expected_vals, actual_vals):
|
|
|
|
return_flag = True
|
|
|
|
if len(expected_vals) != len(actual_vals):
|
|
return False
|
|
|
|
keys = 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,up_templateid,templatestate,zid):
|
|
|
|
config = Configurations.list(
|
|
self.apiclient,
|
|
name='upload.operation.timeout'
|
|
)
|
|
|
|
uploadtimeout = int(config[0].value)
|
|
time.sleep(uploadtimeout*60)
|
|
|
|
list_template_response = Template.list(
|
|
self.apiclient,
|
|
id=up_templateid,
|
|
templatefilter="all",
|
|
zoneid=zid)
|
|
|
|
self.assertNotEqual(
|
|
list_template_response,
|
|
None,
|
|
"Check if template exists in ListTemplates"
|
|
)
|
|
|
|
self.assertEqual(
|
|
list_template_response[0].status,
|
|
templatestate,
|
|
"Check template status in List templates"
|
|
)
|
|
return
|
|
|
|
|
|
|
|
def gettemplatelimts(self):
|
|
|
|
totalresoucelist=Account.list(
|
|
self.apiclient,
|
|
id=self.account.id
|
|
)
|
|
totaltemplates=totalresoucelist[0].templatetotal
|
|
|
|
return(totaltemplates)
|
|
|
|
|
|
def getstoragelimts(self,rtype):
|
|
|
|
cmd=updateResourceCount.updateResourceCountCmd()
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.resourcetype=rtype
|
|
|
|
responce=self.apiclient.updateResourceCount(cmd)
|
|
|
|
totalstorage=responce[0].resourcecount
|
|
|
|
return(totalstorage)
|
|
|
|
|
|
def browse_upload_template(self):
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
cmd.zoneid = self.zone.id
|
|
cmd.format = self.uploadtemplateformat
|
|
cmd.name=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.templatehypervisor
|
|
cmd.ostypeid=self.templateostypeid
|
|
#cmd.isdynamicallyscalable="false"
|
|
#cmd.type="template"
|
|
getuploadparamsresponce=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
|
|
signt=getuploadparamsresponce.signature
|
|
posturl=getuploadparamsresponce.postURL
|
|
metadata=getuploadparamsresponce.metadata
|
|
expiredata=getuploadparamsresponce.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)
|
|
|
|
print results.status_code
|
|
if results.status_code !=200:
|
|
self.fail("Upload is not fine")
|
|
|
|
self.validate_uploaded_template(getuploadparamsresponce.id,'Download Complete',self.zone.id)
|
|
|
|
return(getuploadparamsresponce)
|
|
|
|
|
|
def browse_upload_template_with_out_zoneid(self):
|
|
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
cmd.format = self.uploadtemplateformat
|
|
cmd.name=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.templatehypervisor
|
|
cmd.ostypeid=self.templateostypeid
|
|
|
|
success= False
|
|
try:
|
|
getuploadparamsresponce=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.uploadtemplateformat
|
|
cmd.name=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.templatehypervisor
|
|
|
|
success= False
|
|
try:
|
|
getuploadparamsresponce=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.uploadtemplateformat
|
|
cmd.name=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.templatehypervisor
|
|
cmd.ostypeid=self.templateostypeid
|
|
cmd.projectid=projectid
|
|
#cmd.isdynamicallyscalable="false"
|
|
#cmd.type="template"
|
|
getuploadparamsresponce=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
|
|
signt=getuploadparamsresponce.signature
|
|
posturl=getuploadparamsresponce.postURL
|
|
metadata=getuploadparamsresponce.metadata
|
|
expiredata=getuploadparamsresponce.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)
|
|
|
|
print results.status_code
|
|
if results.status_code !=200:
|
|
self.fail("Upload is not fine")
|
|
|
|
self.validate_uploaded_template(getuploadparamsresponce.id,'Download Complete',self.zone.id)
|
|
|
|
return(getuploadparamsresponce)
|
|
|
|
def browse_upload_template_multiplezones(self,lzones):
|
|
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
cmd.zoneid ="-1"
|
|
cmd.format = self.uploadtemplateformat
|
|
cmd.name=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.templatehypervisor
|
|
cmd.ostypeid=self.templateostypeid
|
|
#cmd.isdynamicallyscalable="false"
|
|
#cmd.type="template"
|
|
getuploadparamsresponce=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
|
|
signt=getuploadparamsresponce.signature
|
|
posturl=getuploadparamsresponce.postURL
|
|
metadata=getuploadparamsresponce.metadata
|
|
expiredata=getuploadparamsresponce.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)
|
|
|
|
print results.status_code
|
|
if results.status_code !=200:
|
|
self.fail("Upload is not fine")
|
|
|
|
for z1 in lzones:
|
|
self.validate_uploaded_template(getuploadparamsresponce.id,'Download Complete',z1.id)
|
|
|
|
return(getuploadparamsresponce)
|
|
|
|
def uploadtemplate(self):
|
|
cmd = getUploadParamsForTemplate.getUploadParamsForTemplateCmd()
|
|
cmd.zoneid = self.zone.id
|
|
cmd.format = self.uploadtemplateformat
|
|
cmd.name=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.account=self.account.name
|
|
cmd.domainid=self.domain.id
|
|
cmd.displaytext=self.templatename+self.account.name+(random.choice(string.ascii_uppercase))
|
|
cmd.hypervisor=self.templatehypervisor
|
|
cmd.ostypeid=self.templateostypeid
|
|
#cmd.type="template"
|
|
getuploadparamsresponce=self.apiclient.getUploadParamsForTemplate(cmd)
|
|
|
|
signt=getuploadparamsresponce.signature
|
|
posturl=getuploadparamsresponce.postURL
|
|
metadata=getuploadparamsresponce.metadata
|
|
expiredata=getuploadparamsresponce.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")
|
|
|
|
return(getuploadparamsresponce)
|
|
|
|
def multiple_browse_upload_template(self):
|
|
|
|
templ1=self.uploadtemplate()
|
|
templ2=self.uploadtemplate()
|
|
templ3=self.uploadtemplate()
|
|
time.sleep(600)
|
|
self.validate_uploaded_template(templ1.id,'Download Complete')
|
|
self.validate_uploaded_template(templ2.id,'Download Complete')
|
|
self.validate_uploaded_template(templ3.id,'Download Complete')
|
|
self.delete_template(templ1)
|
|
self.delete_template(templ2)
|
|
self.delete_template(templ3)
|
|
return
|
|
|
|
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,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(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 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
|
|
)
|
|
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 = 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 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 = 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,
|
|
"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 = 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 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,
|
|
"service cloud status",
|
|
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,
|
|
"service cloud status"
|
|
)
|
|
except KeyError:
|
|
self.skipTest("Marvin configuration has no host credentials to check router services")
|
|
res = str(result)
|
|
self.debug("Cloud Process status: %s" % res)
|
|
# cloud.com service (type=secstorage) is running: process id: 2346
|
|
self.assertEqual(
|
|
res.count("is running"),
|
|
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
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], 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
|
|
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], 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
|
|
|
|
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], 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
|
|
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], 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
|
|
|
|
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], 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()
|
|
afteruploadtemplatelimit=self.gettemplatelimts()
|
|
|
|
if int(afteruploadtemplatelimit)!=(int(initialtemplatelimit)+1):
|
|
self.fail("Volume Resouce Count is not updated")
|
|
|
|
self.delete_template(browseup_template1.id)
|
|
|
|
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_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.getstoragelimts(11)
|
|
browseup_template1=self.browse_upload_template()
|
|
|
|
tmpldetails=Template.list(
|
|
self.apiclient,
|
|
id=browseup_template1.id,
|
|
templatefilter="all",
|
|
zoneid=self.zone.id)
|
|
|
|
|
|
afteruploadsecondarystoragelimit=self.getstoragelimts(11)
|
|
|
|
if afteruploadsecondarystoragelimit!=(initialsecondarystoragelimit+tmpldetails[0].size):
|
|
self.fail("Secondary Storage Resouce Count is not updated")
|
|
|
|
self.delete_template(browseup_template1.id)
|
|
|
|
except Exception as e:
|
|
self.fail("Exception occurred : %s" % e)
|
|
return
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], 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 afteruploadtemplatlimit!=(initialtemplatelimit-1):
|
|
self.fail("Template Resource Count is not updated after deletion")
|
|
|
|
except Exception as e:
|
|
self.fail("Exceptione occurred : %s" % e)
|
|
return
|
|
|
|
|
|
|
|
@attr(tags = ["advanced", "advancedns", "smoke", "basic"], 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.getstoragelimts(11)
|
|
self.delete_template(browseup_template1)
|
|
|
|
afteruploadprimarystoragelimit=self.getstoragelimts(11)
|
|
|
|
if afteruploadprimarystoragelimit!=(initialprimarystoragelimit-tempdetails[0].size):
|
|
self.fail("Secondary Storage Resource Count is not updated after deletion")
|
|
|
|
except Exception as e:
|
|
self.fail("Exception occurred : %s" % e)
|
|
return
|
|
|
|
|
|
@classmethod
|
|
def tearDownClass(self):
|
|
try:
|
|
self.apiclient = super(TestBrowseUploadVolume,self).getClsTestClient().getApiClient()
|
|
cleanup_resources(self.apiclient, self._cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
return
|