mirror of
https://github.com/apache/cloudstack.git
synced 2025-10-26 08:42:29 +01:00
90316b2e90
* VMware - Ignore disk not found error on cleanup when the VM disk doesn't exists * VMware - Retry powerOn on lock issues * addressed comments * Update CPVM reboot tests - wait for the agent to Disconnect and back Up * Retry moveDatastoreFile when any file access issue while creating volume from snapshot * Update full clone flag when restoring vm using root disk offering with more size than the template size * refactored (mainly,for diskInfo - causing NPE in some cases) * Retry moveDatastoreFile when there is any file access issue
1402 lines
46 KiB
Python
1402 lines
46 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.
|
|
""" BVT tests for SSVM
|
|
"""
|
|
# Import Local Modules
|
|
from marvin.cloudstackTestCase import cloudstackTestCase
|
|
from marvin.cloudstackAPI import (stopSystemVm,
|
|
rebootSystemVm,
|
|
destroySystemVm, updateConfiguration)
|
|
from marvin.lib.utils import (cleanup_resources,
|
|
get_process_status,
|
|
get_host_credentials,
|
|
wait_until)
|
|
from marvin.lib.base import (PhysicalNetwork,
|
|
NetScaler, ImageStore)
|
|
from marvin.lib.common import (get_zone,
|
|
list_hosts,
|
|
list_ssvms,
|
|
list_zones,
|
|
list_vlan_ipranges)
|
|
from nose.plugins.attrib import attr
|
|
import telnetlib
|
|
import logging
|
|
|
|
# Import System modules
|
|
import time
|
|
_multiprocess_shared_ = True
|
|
|
|
|
|
class TestSSVMs(cloudstackTestCase):
|
|
|
|
def setUp(self):
|
|
test_case = super(TestSSVMs, self)
|
|
self.apiclient = self.testClient.getApiClient()
|
|
self.hypervisor = self.testClient.getHypervisorInfo()
|
|
self.cleanup = []
|
|
self.config = test_case.getClsConfig()
|
|
self.services = self.testClient.getParsedTestDataConfig()
|
|
self.zone = get_zone(self.apiclient, self.testClient.getZoneForTests())
|
|
|
|
self.logger = logging.getLogger('TestSSVMs')
|
|
self.stream_handler = logging.StreamHandler()
|
|
self.logger.setLevel(logging.DEBUG)
|
|
self.logger.addHandler(self.stream_handler)
|
|
|
|
def tearDown(self):
|
|
try:
|
|
cleanup_resources(self.apiclient, self.cleanup)
|
|
except Exception as e:
|
|
raise Exception("Warning: Exception during cleanup : %s" % e)
|
|
|
|
def waitForSystemVMAgent(self, vmname):
|
|
def checkRunningAgent():
|
|
list_host_response = list_hosts(
|
|
self.apiclient,
|
|
name=vmname
|
|
)
|
|
if isinstance(list_host_response, list):
|
|
return list_host_response[0].state == 'Up', None
|
|
return False, None
|
|
|
|
res, _ = wait_until(3, 300, checkRunningAgent)
|
|
if not res:
|
|
raise Exception("Failed to wait for SSVM agent to be Up")
|
|
|
|
def checkForRunningSystemVM(self, ssvm, ssvm_type=None):
|
|
if not ssvm:
|
|
return None
|
|
|
|
def checkRunningState():
|
|
if not ssvm_type:
|
|
response = list_ssvms(
|
|
self.apiclient,
|
|
id=ssvm.id
|
|
)
|
|
else:
|
|
response = list_ssvms(
|
|
self.apiclient,
|
|
zoneid=self.zone.id,
|
|
systemvmtype=ssvm_type
|
|
)
|
|
|
|
if isinstance(response, list):
|
|
ssvm_response = response[0]
|
|
return ssvm_response.state == 'Running', ssvm_response
|
|
return False, None
|
|
|
|
res, ssvm_response = wait_until(3, 300, checkRunningState)
|
|
if not res:
|
|
self.fail("Failed to reach systemvm state to Running")
|
|
return ssvm_response
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="false")
|
|
def test_01_list_sec_storage_vm(self):
|
|
"""Test List secondary storage VMs
|
|
"""
|
|
|
|
# Validate the following:
|
|
# 1. listSystemVM (systemvmtype=secondarystoragevm)
|
|
# should return only ONE SSVM per zone
|
|
# 2. The returned SSVM should be in Running state
|
|
# 3. listSystemVM for secondarystoragevm should list publicip,
|
|
# privateip, link-localip and service offering id/name
|
|
# 4. The gateway programmed on the ssvm by listSystemVm should be
|
|
# the same as the gateway returned by listVlanIpRanges
|
|
# 5. DNS entries must match those given for the zone
|
|
|
|
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"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(ssvm, 'serviceofferingid'),
|
|
True,
|
|
"Check whether SSVM has service offering id field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(ssvm, 'serviceofferingname'),
|
|
True,
|
|
"Check whether SSVM has service offering name 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"
|
|
)
|
|
|
|
# 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):
|
|
gatewayFound = False
|
|
for iprange in ipranges_response:
|
|
if ssvm.gateway == iprange.gateway:
|
|
gatewayFound = True
|
|
break
|
|
|
|
self.assertTrue(
|
|
gatewayFound,
|
|
"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"
|
|
)
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="false")
|
|
def test_02_list_cpvm_vm(self):
|
|
"""Test List console proxy VMs
|
|
"""
|
|
|
|
# Validate the following:
|
|
# 1. listSystemVM (systemvmtype=consoleproxy) should return
|
|
# at least ONE CPVM per zone
|
|
# 2. The returned ConsoleProxyVM should be in Running state
|
|
# 3. listSystemVM for console proxy should list publicip, privateip,
|
|
# link-localip and service offering id/name
|
|
# 4. The gateway programmed on the console proxy should be the same
|
|
# as the gateway returned by listZones
|
|
# 5. DNS entries must match those given for the zone
|
|
|
|
list_cpvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='consoleproxy',
|
|
state='Running',
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_cpvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
# Verify CPVM response
|
|
self.assertNotEqual(
|
|
len(list_cpvm_response),
|
|
0,
|
|
"Check list System VMs response"
|
|
)
|
|
list_zones_response = list_zones(self.apiclient)
|
|
# Number of Console Proxy VMs = No of Zones
|
|
|
|
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 CPVMs: %s" % len(list_cpvm_response))
|
|
|
|
self.assertEqual(
|
|
len(list_cpvm_response),
|
|
len(list_zones_response),
|
|
"Check number of CPVMs with number of zones"
|
|
)
|
|
# For each CPVM check private IP, public IP, link local IP and DNS
|
|
for cpvm in list_cpvm_response:
|
|
|
|
self.debug("CPVM state: %s" % cpvm.state)
|
|
self.assertEqual(
|
|
cpvm.state,
|
|
'Running',
|
|
"Check whether state of CPVM is running"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(cpvm, 'privateip'),
|
|
True,
|
|
"Check whether CPVM has private IP field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(cpvm, 'linklocalip'),
|
|
True,
|
|
"Check whether CPVM has link local IP field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(cpvm, 'publicip'),
|
|
True,
|
|
"Check whether CPVM has public IP field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(cpvm, 'serviceofferingid'),
|
|
True,
|
|
"Check whether CPVM has service offering id field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(cpvm, 'serviceofferingname'),
|
|
True,
|
|
"Check whether CPVM has service offering name field"
|
|
)
|
|
# Fetch corresponding ip ranges information from listVlanIpRanges
|
|
ipranges_response = list_vlan_ipranges(
|
|
self.apiclient,
|
|
zoneid=cpvm.zoneid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(ipranges_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
|
|
# Fetch corresponding Physical Network of SSVM's Zone
|
|
listphyntwk = PhysicalNetwork.list(
|
|
self.apiclient,
|
|
zoneid=cpvm.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):
|
|
gatewayFound = False
|
|
for iprange in ipranges_response:
|
|
if iprange.gateway == cpvm.gateway:
|
|
gatewayFound = True
|
|
break
|
|
self.assertTrue(
|
|
gatewayFound,
|
|
"Check gateway with that of corresponding ip range"
|
|
)
|
|
|
|
# Fetch corresponding zone information from listZones
|
|
zone_response = list_zones(
|
|
self.apiclient,
|
|
id=cpvm.zoneid
|
|
)
|
|
|
|
self.assertEqual(
|
|
cpvm.dns1,
|
|
zone_response[0].dns1,
|
|
"Check DNS1 with that of corresponding zone"
|
|
)
|
|
|
|
self.assertEqual(
|
|
cpvm.dns2,
|
|
zone_response[0].dns2,
|
|
"Check DNS2 with that of corresponding zone"
|
|
)
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_03_ssvm_internals(self):
|
|
"""Test SSVM Internals"""
|
|
|
|
# Validate the following
|
|
# 1. The SSVM check script should not return any
|
|
# WARN|ERROR|FAIL messages
|
|
# 2. If you are unable to login to the SSVM with the signed key
|
|
# then test is deemed a failure
|
|
# 3. There should be only one ""cloud"" process running within the SSVM
|
|
# 4. If no process is running/multiple process are running
|
|
# then the test is a failure
|
|
|
|
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
|
|
retries = 3
|
|
while retries > -1:
|
|
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
|
|
)
|
|
if ("deactivating" in result) or ("activating" in result):
|
|
if retries >= 0:
|
|
retries = retries - 1
|
|
time.sleep(10)
|
|
continue
|
|
else:
|
|
return result
|
|
else:
|
|
try:
|
|
host.user, host.passwd = get_host_credentials(
|
|
self.config, host.ipaddress)
|
|
retries = 3
|
|
while retries > -1:
|
|
result = get_process_status(
|
|
host.ipaddress,
|
|
22,
|
|
host.user,
|
|
host.passwd,
|
|
ssvm.linklocalip,
|
|
"systemctl is-active cloud"
|
|
)
|
|
print("result is %s" % result)
|
|
if ("deactivating" in result) or ("activating" in result):
|
|
if retries >= 0:
|
|
retries = retries - 1
|
|
time.sleep(10)
|
|
continue
|
|
else:
|
|
return result
|
|
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"
|
|
)
|
|
|
|
linklocal_ip = None
|
|
# 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
|
|
linklocal_ip = ssvm.privateip
|
|
result = get_process_status(
|
|
self.apiclient.connection.mgtSvr,
|
|
22,
|
|
self.apiclient.connection.user,
|
|
self.apiclient.connection.passwd,
|
|
ssvm.privateip,
|
|
"cat /var/cache/cloud/cmdline | xargs | sed \"s/ /\\n/g\" | grep eth1ip= | sed \"s/\=/ /g\" | awk '{print $2}'",
|
|
hypervisor=self.hypervisor
|
|
)
|
|
else:
|
|
try:
|
|
linklocal_ip = ssvm.linklocalip
|
|
host.user, host.passwd = get_host_credentials(
|
|
self.config, host.ipaddress)
|
|
result = get_process_status(
|
|
host.ipaddress,
|
|
22,
|
|
host.user,
|
|
host.passwd,
|
|
ssvm.linklocalip,
|
|
"cat /var/cache/cloud/cmdline | xargs | sed \"s/ /\\n/g\" | grep eth0ip= | sed \"s/\=/ /g\" | awk '{print $2}'"
|
|
)
|
|
except KeyError:
|
|
self.skipTest(
|
|
"Marvin configuration has no host\
|
|
credentials to check router services")
|
|
res = result[0]
|
|
self.debug("Cached Link Local IP: %s" % res)
|
|
self.assertEqual(
|
|
linklocal_ip,
|
|
res,
|
|
"The cached Link Local should be the same as the current Link Local IP, but they are different! Current ==> %s; Cached ==> %s " % (linklocal_ip, res)
|
|
)
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_04_cpvm_internals(self):
|
|
"""Test CPVM Internals"""
|
|
|
|
# Validate the following
|
|
# 1. test that telnet access on 8250 is available to
|
|
# the management server for the CPVM
|
|
# 2. No telnet access, test FAIL
|
|
# 3. Service cloud status should report cloud agent status to be
|
|
# running
|
|
|
|
list_cpvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='consoleproxy',
|
|
state='Running',
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_cpvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
cpvm = list_cpvm_response[0]
|
|
|
|
hosts = list_hosts(
|
|
self.apiclient,
|
|
id=cpvm.hostid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(hosts, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
host = hosts[0]
|
|
|
|
try:
|
|
telnetlib.Telnet(
|
|
str(self.apiclient.connection.mgtSvr),
|
|
'8250'
|
|
)
|
|
self.debug("Telnet management server (IP: %s)" %
|
|
self.apiclient.connection.mgtSvr)
|
|
except Exception as e:
|
|
self.fail(
|
|
"Telnet Access failed for %s: %s" %
|
|
(self.apiclient.connection.mgtSvr, e)
|
|
)
|
|
|
|
self.debug("Checking cloud process status")
|
|
|
|
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,
|
|
cpvm.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,
|
|
cpvm.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)
|
|
self.assertEqual(
|
|
res.count("active"),
|
|
1,
|
|
"Check cloud service is running or not"
|
|
)
|
|
|
|
linklocal_ip = None
|
|
# 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
|
|
linklocal_ip = cpvm.privateip
|
|
result = get_process_status(
|
|
self.apiclient.connection.mgtSvr,
|
|
22,
|
|
self.apiclient.connection.user,
|
|
self.apiclient.connection.passwd,
|
|
cpvm.privateip,
|
|
"cat /var/cache/cloud/cmdline | xargs | sed \"s/ /\\n/g\" | grep eth1ip= | sed \"s/\=/ /g\" | awk '{print $2}'",
|
|
hypervisor=self.hypervisor
|
|
)
|
|
else:
|
|
try:
|
|
linklocal_ip = cpvm.linklocalip
|
|
host.user, host.passwd = get_host_credentials(
|
|
self.config, host.ipaddress)
|
|
result = get_process_status(
|
|
host.ipaddress,
|
|
22,
|
|
host.user,
|
|
host.passwd,
|
|
cpvm.linklocalip,
|
|
"cat /var/cache/cloud/cmdline | xargs | sed \"s/ /\\n/g\" | grep eth0ip= | sed \"s/\=/ /g\" | awk '{print $2}'"
|
|
)
|
|
except KeyError:
|
|
self.skipTest(
|
|
"Marvin configuration has no host\
|
|
credentials to check router services")
|
|
res = result[0]
|
|
self.debug("Cached Link Local IP: %s" % res)
|
|
self.assertEqual(
|
|
linklocal_ip,
|
|
res,
|
|
"The cached Link Local should be the same as the current Link Local IP, but they are different! Current ==> %s; Cached ==> %s " % (linklocal_ip, res)
|
|
)
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_05_stop_ssvm(self):
|
|
"""Test stop SSVM
|
|
"""
|
|
|
|
# Validate the following
|
|
# 1. The SSVM should go to stop state
|
|
# 2. After a brief delay of say one minute, the SSVM should be
|
|
# restarted once again and return to Running state with previous two
|
|
# test cases still passing
|
|
# 3. If either of the two above steps fail the test is a failure
|
|
|
|
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"
|
|
)
|
|
|
|
self.debug("Stopping SSVM: %s" % ssvm.id)
|
|
cmd = stopSystemVm.stopSystemVmCmd()
|
|
cmd.id = ssvm.id
|
|
self.apiclient.stopSystemVm(cmd)
|
|
|
|
ssvm_response = self.checkForRunningSystemVM(ssvm)
|
|
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.test_01_list_sec_storage_vm()
|
|
|
|
self.test_03_ssvm_internals()
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_06_stop_cpvm(self):
|
|
"""Test stop CPVM
|
|
"""
|
|
|
|
# Validate the following
|
|
# 1. The CPVM should go to stop state
|
|
# 2. After a brief delay of say one minute, the SSVM should be
|
|
# restarted once again and return to Running state with previous
|
|
# two test cases still passing
|
|
# 3. If either of the two above steps fail the test is a failure
|
|
|
|
list_cpvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='consoleproxy',
|
|
state='Running',
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_cpvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
cpvm = list_cpvm_response[0]
|
|
|
|
hosts = list_hosts(
|
|
self.apiclient,
|
|
id=cpvm.hostid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(hosts, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
|
|
self.debug("Stopping CPVM: %s" % cpvm.id)
|
|
cmd = stopSystemVm.stopSystemVmCmd()
|
|
cmd.id = cpvm.id
|
|
self.apiclient.stopSystemVm(cmd)
|
|
|
|
cpvm_response = self.checkForRunningSystemVM(cpvm)
|
|
self.debug("CPVM state after debug: %s" % cpvm_response.state)
|
|
|
|
self.assertEqual(
|
|
cpvm_response.state,
|
|
'Running',
|
|
"Check whether CPVM is running or not"
|
|
)
|
|
|
|
# Wait for the agent to be up
|
|
self.waitForSystemVMAgent(cpvm_response.name)
|
|
|
|
# Call above tests to ensure CPVM is properly running
|
|
self.test_02_list_cpvm_vm()
|
|
|
|
self.test_04_cpvm_internals()
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_07_reboot_ssvm(self):
|
|
"""Test reboot SSVM
|
|
"""
|
|
# Validate the following
|
|
# 1. The SSVM should go to stop and return to Running state
|
|
# 2. SSVM's public-ip and private-ip must remain the same
|
|
# before and after reboot
|
|
# 3. The cloud process should still be running within the SSVM
|
|
|
|
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"
|
|
)
|
|
|
|
# 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)
|
|
|
|
ssvm_response = self.checkForRunningSystemVM(ssvm_response)
|
|
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"
|
|
)
|
|
|
|
# Private IP Address of System VMs are allowed to change after reboot - CLOUDSTACK-7745
|
|
|
|
# Wait for the agent to be up
|
|
self.waitForSystemVMAgent(ssvm_response.name)
|
|
|
|
# Wait until NFS stores mounted before running the script
|
|
time.sleep(90)
|
|
# Call to verify cloud process is running
|
|
self.test_03_ssvm_internals()
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_08_reboot_cpvm(self):
|
|
"""Test reboot CPVM
|
|
"""
|
|
# Validate the following
|
|
# 1. The CPVM should go to stop and return to Running state
|
|
# 2. CPVM's public-ip and private-ip must remain
|
|
# the same before and after reboot
|
|
# 3. the cloud process should still be running within the CPVM
|
|
|
|
list_cpvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='consoleproxy',
|
|
state='Running',
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_cpvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
cpvm_response = list_cpvm_response[0]
|
|
|
|
hosts = list_hosts(
|
|
self.apiclient,
|
|
id=cpvm_response.hostid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(hosts, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
|
|
# Store the public & private IP values before reboot
|
|
old_public_ip = cpvm_response.publicip
|
|
old_private_ip = cpvm_response.privateip
|
|
|
|
self.debug("Rebooting CPVM: %s" % cpvm_response.id)
|
|
|
|
cmd = rebootSystemVm.rebootSystemVmCmd()
|
|
cmd.id = cpvm_response.id
|
|
self.apiclient.rebootSystemVm(cmd)
|
|
|
|
cpvm_response = self.checkForRunningSystemVM(cpvm_response)
|
|
self.debug("CPVM state: %s" % cpvm_response.state)
|
|
self.assertEqual(
|
|
'Running',
|
|
str(cpvm_response.state),
|
|
"Check whether CPVM is running or not"
|
|
)
|
|
|
|
self.assertEqual(
|
|
cpvm_response.publicip,
|
|
old_public_ip,
|
|
"Check Public IP after reboot with that of before reboot"
|
|
)
|
|
|
|
# Private IP Address of System VMs are allowed to change after reboot - CLOUDSTACK-7745
|
|
|
|
# Agent in Up state for a while after reboot, wait for the agent to Disconnect and back Up.
|
|
time.sleep(60)
|
|
|
|
# Wait for the agent to be up
|
|
self.waitForSystemVMAgent(cpvm_response.name)
|
|
|
|
# Call to verify cloud process is running
|
|
self.test_04_cpvm_internals()
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_09_reboot_ssvm_forced(self):
|
|
"""Test force reboot SSVM
|
|
"""
|
|
|
|
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"
|
|
)
|
|
|
|
self.debug("Force rebooting SSVM: %s" % ssvm_response.id)
|
|
cmd = rebootSystemVm.rebootSystemVmCmd()
|
|
cmd.id = ssvm_response.id
|
|
cmd.forced = True
|
|
self.apiclient.rebootSystemVm(cmd)
|
|
|
|
ssvm_response = self.checkForRunningSystemVM(ssvm_response)
|
|
self.debug("SSVM State: %s" % ssvm_response.state)
|
|
self.assertEqual(
|
|
'Running',
|
|
str(ssvm_response.state),
|
|
"Check whether SSVM is running or not"
|
|
)
|
|
|
|
# Wait for the agent to be up
|
|
self.waitForSystemVMAgent(ssvm_response.name)
|
|
|
|
# Wait until NFS stores mounted before running the script
|
|
time.sleep(90)
|
|
# Call to verify cloud process is running
|
|
self.test_03_ssvm_internals()
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_10_reboot_cpvm_forced(self):
|
|
"""Test force reboot CPVM
|
|
"""
|
|
|
|
list_cpvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='consoleproxy',
|
|
state='Running',
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_cpvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
cpvm_response = list_cpvm_response[0]
|
|
|
|
hosts = list_hosts(
|
|
self.apiclient,
|
|
id=cpvm_response.hostid
|
|
)
|
|
self.assertEqual(
|
|
isinstance(hosts, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
|
|
self.debug("Force rebooting CPVM: %s" % cpvm_response.id)
|
|
|
|
cmd = rebootSystemVm.rebootSystemVmCmd()
|
|
cmd.id = cpvm_response.id
|
|
cmd.forced = True
|
|
self.apiclient.rebootSystemVm(cmd)
|
|
|
|
cpvm_response = self.checkForRunningSystemVM(cpvm_response)
|
|
self.debug("CPVM state: %s" % cpvm_response.state)
|
|
self.assertEqual(
|
|
'Running',
|
|
str(cpvm_response.state),
|
|
"Check whether CPVM is running or not"
|
|
)
|
|
|
|
# Agent in Up state for a while after reboot, wait for the agent to Disconnect and back Up.
|
|
time.sleep(60)
|
|
|
|
# Wait for the agent to be up
|
|
self.waitForSystemVMAgent(cpvm_response.name)
|
|
|
|
# Call to verify cloud process is running
|
|
self.test_04_cpvm_internals()
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_11_destroy_ssvm(self):
|
|
"""Test destroy SSVM
|
|
"""
|
|
|
|
# Validate the following
|
|
# 1. SSVM should be completely destroyed and a new one will spin up
|
|
# 2. listSystemVMs will show a different name for the
|
|
# systemVM from what it was before
|
|
# 3. new SSVM will have a public/private and link-local-ip
|
|
# 4. cloud process within SSVM must be up and running
|
|
|
|
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)
|
|
|
|
ssvm_response = self.checkForRunningSystemVM(ssvm_response, 'secondarystoragevm')
|
|
|
|
# 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)
|
|
|
|
# Call to verify cloud process is running
|
|
self.test_03_ssvm_internals()
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_12_destroy_cpvm(self):
|
|
"""Test destroy CPVM
|
|
"""
|
|
|
|
# Validate the following
|
|
# 1. CPVM should be completely destroyed and a new one will spin up
|
|
# 2. listSystemVMs will show a different name for the systemVM from
|
|
# what it was before
|
|
# 3. new CPVM will have a public/private and link-local-ip
|
|
# 4. cloud process within CPVM must be up and running
|
|
|
|
list_cpvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='consoleproxy',
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_cpvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
cpvm_response = list_cpvm_response[0]
|
|
|
|
old_name = cpvm_response.name
|
|
|
|
self.debug("Destroying CPVM: %s" % cpvm_response.id)
|
|
cmd = destroySystemVm.destroySystemVmCmd()
|
|
cmd.id = cpvm_response.id
|
|
self.apiclient.destroySystemVm(cmd)
|
|
|
|
cpvm_response = self.checkForRunningSystemVM(cpvm_response, 'consoleproxy')
|
|
|
|
# Verify Name, Public IP, Private IP and Link local IP
|
|
# for newly created CPVM
|
|
self.assertNotEqual(
|
|
cpvm_response.name,
|
|
old_name,
|
|
"Check SSVM new name with name of destroyed CPVM"
|
|
)
|
|
self.assertEqual(
|
|
hasattr(cpvm_response, 'privateip'),
|
|
True,
|
|
"Check whether CPVM has private IP field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(cpvm_response, 'linklocalip'),
|
|
True,
|
|
"Check whether CPVM has link local IP field"
|
|
)
|
|
|
|
self.assertEqual(
|
|
hasattr(cpvm_response, 'publicip'),
|
|
True,
|
|
"Check whether CPVM has public IP field"
|
|
)
|
|
|
|
# Wait for the agent to be up
|
|
self.waitForSystemVMAgent(cpvm_response.name)
|
|
|
|
# Call to verify cloud process is running
|
|
self.test_04_cpvm_internals()
|
|
|
|
@attr(
|
|
tags=[
|
|
"advanced",
|
|
"advancedns",
|
|
"smoke",
|
|
"basic",
|
|
"sg"],
|
|
required_hardware="true")
|
|
def test_13_ss_nfs_version_on_ssvm(self):
|
|
"""Test NFS Version on Secondary Storage mounted properly on SSVM
|
|
"""
|
|
|
|
# 1) List SSVM in zone
|
|
# 2) Get id and url from mounted nfs store
|
|
# 3) Update NFS version for previous image store
|
|
# 4) Stop SSVM
|
|
# 5) Check NFS version of mounted nfs store after SSVM starts
|
|
|
|
nfs_version = self.config.nfsVersion
|
|
if nfs_version == None:
|
|
self.skipTest('No NFS version provided in test data')
|
|
|
|
#List SSVM for zone id
|
|
list_ssvm_response = list_ssvms(
|
|
self.apiclient,
|
|
systemvmtype='secondarystoragevm',
|
|
state='Running',
|
|
zoneid=self.zone.id
|
|
)
|
|
self.assertNotEqual(
|
|
list_ssvm_response,
|
|
None
|
|
)
|
|
self.assertEqual(
|
|
isinstance(list_ssvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
self.assertEqual(
|
|
len(list_ssvm_response),
|
|
1,
|
|
"Check list System VMs response"
|
|
)
|
|
|
|
ssvm = list_ssvm_response[0]
|
|
image_stores_response = ImageStore.list(self.apiclient,zoneid=self.zone.id)
|
|
|
|
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,
|
|
"mount | grep 'type nfs'",
|
|
hypervisor=self.hypervisor)
|
|
|
|
for res in result:
|
|
split_res = res.split("on")
|
|
mounted_img_store_url = split_res[0].strip()
|
|
for img_store in image_stores_response:
|
|
img_store_url = str(img_store.url)
|
|
if img_store_url.startswith("nfs://"):
|
|
img_store_url = img_store_url[6:]
|
|
#Add colon after ip address to match output from mount command
|
|
first_slash = img_store_url.find('/')
|
|
img_store_url = img_store_url[0:first_slash] + ':' + img_store_url[first_slash:]
|
|
if img_store_url == mounted_img_store_url:
|
|
img_store_id = img_store.id
|
|
break
|
|
|
|
self.assertNotEqual(
|
|
img_store_id,
|
|
None,
|
|
"Check image store id mounted on SSVM"
|
|
)
|
|
|
|
#Update NFS version for image store mounted on SSVM
|
|
updateConfigurationCmd = updateConfiguration.updateConfigurationCmd()
|
|
updateConfigurationCmd.name = "secstorage.nfs.version"
|
|
updateConfigurationCmd.value = nfs_version
|
|
updateConfigurationCmd.imagestoreuuid = img_store_id
|
|
|
|
updateConfigurationResponse = self.apiclient.updateConfiguration(updateConfigurationCmd)
|
|
self.logger.debug("updated the parameter %s with value %s"%(updateConfigurationResponse.name, updateConfigurationResponse.value))
|
|
|
|
#Stop SSVM
|
|
self.debug("Stopping SSVM: %s" % ssvm.id)
|
|
cmd = stopSystemVm.stopSystemVmCmd()
|
|
cmd.id = ssvm.id
|
|
self.apiclient.stopSystemVm(cmd)
|
|
|
|
new_list_ssvm_response = self.checkForRunningSystemVM(ssvm)
|
|
|
|
self.assertNotEqual(
|
|
new_list_ssvm_response,
|
|
None
|
|
)
|
|
self.assertEqual(
|
|
isinstance(new_list_ssvm_response, list),
|
|
True,
|
|
"Check list response returns a valid list"
|
|
)
|
|
ssvm = new_list_ssvm_response[0]
|
|
self.debug("SSVM state after debug: %s" % ssvm.state)
|
|
self.assertEqual(
|
|
ssvm.state,
|
|
'Running',
|
|
"Check whether SSVM is running or not"
|
|
)
|
|
# Wait for the agent to be up
|
|
self.waitForSystemVMAgent(ssvm.name)
|
|
|
|
#Check NFS version on mounted image store
|
|
result = get_process_status(
|
|
self.apiclient.connection.mgtSvr,
|
|
22,
|
|
self.apiclient.connection.user,
|
|
self.apiclient.connection.passwd,
|
|
ssvm.privateip,
|
|
"mount | grep '%s'"%mounted_img_store_url,
|
|
hypervisor=self.hypervisor)
|
|
|
|
self.assertNotEqual(
|
|
result,
|
|
None
|
|
)
|
|
self.assertEqual(
|
|
len(result),
|
|
1,
|
|
"Check result length"
|
|
)
|
|
|
|
res = result[0]
|
|
mounted_nfs_version = res.split("vers=")[1][0:1]
|
|
self.assertEqual(
|
|
int(mounted_nfs_version),
|
|
int(nfs_version),
|
|
"Check mounted NFS version to be the same as provided"
|
|
)
|