def test_assign_max_pci_to_single_instance(self):
pci.get_pci_config(self)
for info, count in zip(self.infoList, self.countList):
count = int(count)
info = info.split(":")
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self, name, count)
admin_pass = self.image_ssh_password
resp, server_with_pci = self.create_test_server(
wait_until="ACTIVE", adminPass=admin_pass, flavor=flavor_with_pci_id
)
resp, address = self.client.list_addresses(server_with_pci["id"])
addresses = {"addresses": address}
password = "******"
linux_client = remote_client.RemoteClient(addresses, self.ssh_user, password)
pci_flag = linux_client.get_pci(pciid)
self.assertTrue(pci_flag is not None)
pci_count = linux_client.get_pci_count(pciid)
pci_count = pci_count.strip("")
pci_count = int(pci_count)
self.assertEqual(count, pci_count)
def test_assign_single_pci_to_instance(self):
#Get PCI related parameter and ready
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self,name)
admin_pass = self.image_ssh_password
resp, server_with_pci = (self.create_test_server(
wait_until='ACTIVE',
adminPass=admin_pass,
flavor=flavor_with_pci_id))
resp, address = self.client.list_addresses(server_with_pci['id'])
addresses = {'addresses':address}
password = '******'
linux_client = remote_client.RemoteClient(addresses,
self.ssh_user, password)
pci_flag = linux_client.get_pci(pciid)
self.assertTrue(pci_flag is not None)
pci_count = linux_client.get_pci_count(pciid)
pci_count = pci_count.strip()
self.assertEqual('1',pci_count)
def test_assign_max_pci_to_single_instance(self):
pci.get_pci_config(self)
for info, count in zip(self.infoList, self.countList):
count = int(count)
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(
self, name, count)
admin_pass = self.image_ssh_password
resp, server_with_pci = (self.create_test_server(
wait_until='ACTIVE',
adminPass=admin_pass,
flavor=flavor_with_pci_id))
resp, address = self.client.list_addresses(server_with_pci['id'])
addresses = {'addresses': address}
password = '******'
linux_client = remote_client.RemoteClient(addresses, self.ssh_user,
password)
pci_flag = linux_client.get_pci(pciid)
self.assertTrue(pci_flag is not None)
pci_count = linux_client.get_pci_count(pciid)
pci_count = pci_count.strip('')
pci_count = int(pci_count)
self.assertEqual(count, pci_count)
def test_assign_pci_stop_start_instance(self):
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self,name)
admin_pass = self.image_ssh_password
p, _ = pci.gen_rc_local_file()
cont = pci.gen_rc_local_dict(pci.RC_LSPCI)
# fstab = pci.gen_etc_fstab()
print cont
personality = [
{'path': "/etc/rc.local",
'contents': cont}]
# {'path': "/etc/fstab",
# 'contents': fstab}]
user_data = pci.gen_user_data("\n".join(pci.CONSOLE_DATA))
server_with_pci = (self.create_test_server(
wait_until='ACTIVE',
user_data=user_data,
personality=personality,
adminPass=admin_pass,
flavor=flavor_with_pci_id))
addresses = self.client.show_server(server_with_pci['id'])['server']
password = '******'
self.server_id = server_with_pci['id']
print self.server_id
print "cubswin:)"
pci_info = pci.retry_get_pci_output(
self.client.get_console_output, self.server_id)
expect_pci = filter(lambda x: pciid in x, pci_info)
self.assertTrue(not not expect_pci)
pci_count = len(expect_pci)
self.assertEqual(1, pci_count)
self.servers_client.reboot_server(self.server_id, type='HARD')
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
print self.server_id
print "cubswin:)"
pci_info = pci.retry_get_pci_output(
self.client.get_console_output, self.server_id,
DELIMITER="RC LSPCI")
expect_pci = filter(lambda x: pciid in x, pci_info)
self.assertTrue(not not expect_pci)
pci_count = len(expect_pci)
self.assertEqual(1, pci_count)
def test_assign_single_pci_to_instance(self):
#Get PCI related parameter and ready
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self,name)
admin_pass = self.image_ssh_password
p, _ = pci.gen_rc_local_file()
cont = pci.gen_rc_local_dict()
fstab = pci.gen_etc_fstab()
cont = pci.gen_rc_local_dict(pci.RC_LSPCI)
# personality = []
personality = [
{'path': "/etc/rc.local",
'contents': cont}]
user_data = pci.gen_user_data("\n".join(pci.CONSOLE_DATA))
server_with_pci = (self.create_test_server(
wait_until='ACTIVE',
adminPass=admin_pass,
user_data=user_data,
personality=personality,
flavor=flavor_with_pci_id))
#print self.client.get_server_metadata_item(server_with_pci['id'],"addresses")
addresses = self.client.show_server(server_with_pci['id'])['server']
password = '******'
print "cirros@" + addresses["addresses"]["private"][0]["addr"]
print password
pci_info = pci.retry_get_pci_output(
self.client.get_console_output, server_with_pci["id"])
# pci_info = pci.get_pci_info(disk)
# pci_flag = linux_client.get_pci(pciid)
expect_pci = filter(lambda x: pciid in x, pci_info)
# self.assertTrue(pci_flag is not None)
self.assertTrue(not not expect_pci)
# pci_count = linux_client.get_pci_count(pciid)
pci_count = len(expect_pci)
# pci_count = pci_count.strip()
self.assertEqual(1, pci_count)
def test_assign_single_pci_to_instance(self):
#Get PCI related parameter and ready
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self, name)
admin_pass = self.image_ssh_password
p, _ = pci.gen_rc_local_file()
cont = pci.gen_rc_local_dict()
fstab = pci.gen_etc_fstab()
cont = pci.gen_rc_local_dict(pci.RC_LSPCI)
# personality = []
personality = [{'path': "/etc/rc.local", 'contents': cont}]
user_data = pci.gen_user_data("\n".join(pci.CONSOLE_DATA))
server_with_pci = (self.create_test_server(
wait_until='ACTIVE',
adminPass=admin_pass,
user_data=user_data,
personality=personality,
flavor=flavor_with_pci_id))
#print self.client.get_server_metadata_item(server_with_pci['id'],"addresses")
addresses = self.client.show_server(
server_with_pci['id'])['server']
password = '******'
print "cirros@" + addresses["addresses"]["private"][0]["addr"]
print password
pci_info = pci.retry_get_pci_output(self.client.get_console_output,
server_with_pci["id"])
# pci_info = pci.get_pci_info(disk)
# pci_flag = linux_client.get_pci(pciid)
expect_pci = filter(lambda x: pciid in x, pci_info)
# self.assertTrue(pci_flag is not None)
self.assertTrue(not not expect_pci)
# pci_count = linux_client.get_pci_count(pciid)
pci_count = len(expect_pci)
# pci_count = pci_count.strip()
self.assertEqual(1, pci_count)
def test_assign_pci_hard_reboot_instance(self):
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self,name)
admin_pass = self.image_ssh_password
resp, server_with_pci = (self.create_test_server(
wait_until='ACTIVE',
adminPass=admin_pass,
flavor=flavor_with_pci_id))
self.server_id = server_with_pci['id']
resp, address = self.client.list_addresses(server_with_pci['id'])
addresses = {'addresses':address}
password = '******'
if self.run_ssh:
resp, server = self.client.get_server(self.server_id)
linux_client = remote_client.RemoteClient(addresses,
self.ssh_user, password)
boot_time = linux_client.get_boot_time()
pci_flag = linux_client.get_pci(pciid)
self.assertTrue(pci_flag is not None)
pci_count = linux_client.get_pci_count(pciid)
pci_count = pci_count.strip()
self.assertEqual('1',pci_count)
resp, body = self.client.reboot(self.server_id, 'HARD')
self.assertEqual(202, resp.status)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
if self.run_ssh:
# Log in and verify the boot time has changed
linux_client = remote_client.RemoteClient(addresses, self.ssh_user,
password)
pci_new = linux_client.get_pci(pciid)
self.assertTrue(pci_new is not None)
pci_count = linux_client.get_pci_count(pciid)
pci_count = pci_count.strip()
self.assertEqual('1',pci_count)
def test_assign_pci_resize_revert_instance(self):
#Get PCI related parameter and ready to test
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self,name)
admin_pass = self.image_ssh_password
resp, server_with_pci = (self.create_test_server(
wait_until='ACTIVE',
adminPass=admin_pass,
flavor=flavor_with_pci_id))
resp, address = self.client.list_addresses(server_with_pci['id'])
addresses = {'addresses':address}
password = '******'
linux_client = remote_client.RemoteClient(addresses,
self.ssh_user, password)
pci_flag = linux_client.get_pci(pciid)
self.assertTrue(pci_flag is not None)
pci_count = linux_client.get_pci_count(pciid)
pci_count = pci_count.strip()
self.assertEqual('1',pci_count)
self.server_id = server_with_pci['id']
new_flavor_ref = pci.create_flavor_with_extra_specs(self,name,count=2)
resp, server = self.client.resize(self.server_id, new_flavor_ref)
self.assertEqual(202, resp.status)
self.client.wait_for_server_status(self.server_id, 'VERIFY_RESIZE')
self.client.revert_resize(self.server_id)
self.client.wait_for_server_status(self.server_id, 'ACTIVE')
# Need to poll for the id change until lp#924371 is fixed
resp, server = self.client.get_server(self.server_id)
pci_recover_flag = linux_client.get_pci(pciid)
self.assertTrue(pci_recover_flag is not None)
pci_count = linux_client.get_pci_count(pciid)
pci_count = pci_count.strip()
self.assertEqual('1',pci_count)
def test_assign_pci_stop_start_instance(self):
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self,name)
admin_pass = self.image_ssh_password
resp, server_with_pci = (self.create_test_server(
wait_until='ACTIVE',
adminPass=admin_pass,
flavor=flavor_with_pci_id))
resp, address = self.client.list_addresses(server_with_pci['id'])
addresses = {'addresses':address}
password = '******'
self.server_id = server_with_pci['id']
linux_client = remote_client.RemoteClient(addresses,
self.ssh_user, password)
pci_flag = linux_client.get_pci(pciid)
self.assertTrue(pci_flag is not None)
pci_count = linux_client.get_pci_count(pciid)
pci_count = pci_count.strip()
self.assertEqual('1',pci_count)
resp, server = self.servers_client.stop(self.server_id)
self.assertEqual(202, resp.status)
self.servers_client.wait_for_server_status(self.server_id, 'SHUTOFF')
resp, server = self.servers_client.start(self.server_id)
self.assertEqual(202, resp.status)
self.servers_client.wait_for_server_status(self.server_id, 'ACTIVE')
linux_client = remote_client.RemoteClient(addresses,
self.ssh_user, password)
pci_recover_flag = linux_client.get_pci(pciid)
self.assertTrue(pci_recover_flag is not None)
pci_count = linux_client.get_pci_count(pciid)
pci_count = pci_count.strip()
self.assertEqual('1',pci_count)
def test_assign_pci_suspend_resume_instance(self):
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self,name)
admin_pass = self.image_ssh_password
p, _ = pci.gen_rc_local_file()
cont = pci.gen_rc_local_dict(pci.RC_LSPCI)
# fstab = pci.gen_etc_fstab()
print cont
personality = [
{'path': "/etc/rc.local",
'contents': cont}]
# {'path': "/etc/fstab",
# 'contents': fstab}]
user_data = pci.gen_user_data("\n".join(pci.SUSPEND_PAUSE_CONSOLE_DATA))
server_with_pci = (self.create_test_server(
wait_until='ACTIVE',
user_data=user_data,
#personality=personality,
adminPass=admin_pass,
flavor=flavor_with_pci_id))
addresses = self.client.show_server(server_with_pci['id'])['server']
password = '******'
self.server_id = server_with_pci['id']
print self.server_id
print "cubswin:)"
pci_info = pci.retry_get_pci_output(
self.client.get_console_output, self.server_id)
expect_pci = filter(lambda x: pciid in x, pci_info)
self.assertTrue(not not expect_pci)
pci_count = len(expect_pci)
self.assertEqual(1, pci_count)
#import pdb;pdb.set_trace()
time.sleep(3)
self.client.suspend_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id, 'SUSPENDED')
self.client.resume_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
print self.server_id
print "cubswin:)"
cmd = ["sudo", "virsh", "dumpxml", server_with_pci["id"]]
xml = pci.shell_command(cmd)
serial_path = pci.get_serial_path(xml)
cmd = ["sudo", "chmod", "a+wr", serial_path]
pci.shell_command(cmd)
ser = serial.Serial(port=serial_path, baudrate=38400, timeout=1)
for x in range(10):
ser.write('0\n')
time.sleep(1)
str = ser.readall()
if str.count('2') > 0 :
break
ser.close()
pci_info = pci.retry_get_pci_output(
self.client.get_console_output, self.server_id,
DELIMITER="SP LSPCI")
expect_pci = filter(lambda x: pciid in x, pci_info)
self.assertTrue(not not expect_pci)
pci_count = len(expect_pci)
self.assertEqual(1, pci_count)
def test_assign_pci_pause_unpause_instance(self):
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self,name)
admin_pass = self.image_ssh_password
user_data = pci.gen_user_data("\n".join(pci.SUSPEND_PAUSE_CONSOLE_DATA))
server_with_pci = (self.create_test_server(
wait_until='ACTIVE',
user_data=user_data,
#personality=personality,
adminPass=admin_pass,
flavor=flavor_with_pci_id))
addresses = self.client.show_server(server_with_pci['id'])['server']
password = '******'
self.server_id = server_with_pci['id']
print self.server_id
print "cubswin:)"
pci_info = pci.retry_get_pci_output(
self.client.get_console_output, self.server_id)
expect_pci = filter(lambda x: pciid in x, pci_info)
self.assertTrue(not not expect_pci)
pci_count = len(expect_pci)
self.assertEqual(1, pci_count)
#self.server_id = server_with_pci['id']
#linux_client = remote_client.RemoteClient(addresses,
# self.ssh_user, password)
#pci_flag = linux_client.get_pci(pciid)
#self.assertTrue(pci_flag is not None)
#pci_count = linux_client.get_pci_count(pciid)
#pci_count = pci_count.strip()
#self.assertEqual('1',pci_count)
self.client.pause_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id, 'PAUSED')
self.client.unpause_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
cmd = ["sudo", "virsh", "dumpxml", server_with_pci["id"]]
xml = pci.shell_command(cmd)
serial_path = pci.get_serial_path(xml)
cmd = ["sudo", "chmod", "a+wr", serial_path]
pci.shell_command(cmd)
ser = serial.Serial(port=serial_path, baudrate=38400, timeout=1)
for x in range(10):
ser.write('0\n')
time.sleep(1)
str = ser.readall()
if str.count('2') > 0 :
break
ser.close()
pci_info = pci.retry_get_pci_output(
self.client.get_console_output, self.server_id,
DELIMITER="SP LSPCI")
expect_pci = filter(lambda x: pciid in x, pci_info)
self.assertTrue(not not expect_pci)
pci_count = len(expect_pci)
self.assertEqual(1, pci_count)
def test_assign_pci_resize_revert_instance(self):
#Get PCI related parameter and ready to test
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self,name)
admin_pass = self.image_ssh_password
cont = pci.gen_rc_local_dict(pci.RC_LSPCI)
print cont
personality = [
{'path': "/etc/rc.local",
'contents': cont}]
user_data = pci.gen_user_data("\n".join(pci.CONSOLE_DATA))
server_with_pci = self.create_test_server(
wait_until='ACTIVE',
user_data=user_data,
personality=personality,
adminPass=admin_pass,
flavor=flavor_with_pci_id)
addresses = self.client.show_server(server_with_pci['id'])['server']
password = '******'
self.server_id = server_with_pci['id']
print self.server_id
print "cubswin:)"
#import pdb; pdb.set_trace()
pci_info = pci.retry_get_pci_output(
self.client.get_console_output, self.server_id)
expect_pci = filter(lambda x: pciid in x, pci_info)
self.assertTrue(not not expect_pci)
pci_count = len(expect_pci)
self.assertEqual(1, pci_count)
# resp, server_with_pci = (self.create_test_server(
# wait_until='ACTIVE',
# adminPass=admin_pass,
# flavor=flavor_with_pci_id))
#
# resp, address = self.client.list_addresses(server_with_pci['id'])
#
# addresses = {'addresses':address}
#
# password = '******'
#
# linux_client = remote_client.RemoteClient(addresses,
# self.ssh_user, password)
# pci_flag = linux_client.get_pci(pciid)
# self.assertTrue(pci_flag is not None)
# pci_count = linux_client.get_pci_count(pciid)
# pci_count = pci_count.strip()
# self.assertEqual('1',pci_count)
#
self.server_id = server_with_pci['id']
new_flavor_ref = pci.create_flavor_with_extra_specs(self,name,count=2)
self.client.resize_server(self.server_id, new_flavor_ref)
#self.assertEqual(202, resp.status)
waiters.wait_for_server_status(self.client, self.server_id, 'VERIFY_RESIZE')
self.client.revert_resize_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id, 'ACTIVE')
pci_info = pci.retry_get_pci_output(
self.client.get_console_output, self.server_id,
DELIMITER="RC LSPCI")
#import pdb; pdb.set_trace()
expect_pci = filter(lambda x: pciid in x, pci_info)
self.assertTrue(not not expect_pci)
pci_count = len(expect_pci)
self.assertEqual(1, pci_count)
def test_assign_pci_pause_unpause_instance(self):
pci.get_pci_config(self)
for info in self.infoList:
info = info.split(':')
name = info[0]
pciid = info[1]
flavor_with_pci_id = pci.create_flavor_with_extra_specs(self, name)
admin_pass = self.image_ssh_password
user_data = pci.gen_user_data("\n".join(
pci.SUSPEND_PAUSE_CONSOLE_DATA))
server_with_pci = (
self.create_test_server(
wait_until='ACTIVE',
user_data=user_data,
#personality=personality,
adminPass=admin_pass,
flavor=flavor_with_pci_id))
addresses = self.client.show_server(
server_with_pci['id'])['server']
password = '******'
self.server_id = server_with_pci['id']
print self.server_id
print "cubswin:)"
pci_info = pci.retry_get_pci_output(self.client.get_console_output,
self.server_id)
expect_pci = filter(lambda x: pciid in x, pci_info)
self.assertTrue(not not expect_pci)
pci_count = len(expect_pci)
self.assertEqual(1, pci_count)
#self.server_id = server_with_pci['id']
#linux_client = remote_client.RemoteClient(addresses,
# self.ssh_user, password)
#pci_flag = linux_client.get_pci(pciid)
#self.assertTrue(pci_flag is not None)
#pci_count = linux_client.get_pci_count(pciid)
#pci_count = pci_count.strip()
#self.assertEqual('1',pci_count)
self.client.pause_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id,
'PAUSED')
self.client.unpause_server(self.server_id)
waiters.wait_for_server_status(self.client, self.server_id,
'ACTIVE')
cmd = ["sudo", "virsh", "dumpxml", server_with_pci["id"]]
xml = pci.shell_command(cmd)
serial_path = pci.get_serial_path(xml)
cmd = ["sudo", "chmod", "a+wr", serial_path]
pci.shell_command(cmd)
ser = serial.Serial(port=serial_path, baudrate=38400, timeout=1)
for x in range(10):
ser.write('0\n')
time.sleep(1)
str = ser.readall()
if str.count('2') > 0:
break
ser.close()
pci_info = pci.retry_get_pci_output(self.client.get_console_output,
self.server_id,
DELIMITER="SP LSPCI")
expect_pci = filter(lambda x: pciid in x, pci_info)
self.assertTrue(not not expect_pci)
pci_count = len(expect_pci)
self.assertEqual(1, pci_count)
