def _create_instance(self,
image,
flavor,
pubkey,
name,
network="",
wait_for_active=True):
if network != "":
network = "--nic net-id={0}".format(network)
else:
# Get tftp private network ID
net_cmd = "neutron net-show tftp"
result = self.cli.execute_cmd(net_cmd)
tftp_network = parser.details(result)
net_id = tftp_network.get("id")
network = "--nic net-id={0}".format(net_id)
cmd = "nova boot --flavor {0} --image '{1}' --key-name {2} " \
"--security-group rpc-support,default {3} {4}"\
.format(flavor, image, pubkey, network, name)
result = self.cli.execute_cmd(cmd)
server = parser.details(result)
server_id = server.get("id")
self.resource_deletion.append("nova delete {0}".format(server_id))
# Wait for instance to go to ACTIVE
show_cmd = "nova show {0}".format(server_id)
if wait_for_active:
server = self._wait_for_status(show_cmd, "status", "ACTIVE")
self.assertEqual(server.get("status"), "ACTIVE")
return server
def _wait_for_status(self, cmd, status_key, status_value):
result = self.cli.execute_cmd(cmd)
resource = parser.details(result)
attempts = 0
while resource.get(status_key) != status_value and attempts < 40:
if resource.get(status_key).lower() == "error":
return resource
attempts += 1
time.sleep(15)
result = self.cli.execute_cmd(cmd)
resource = parser.details(result)
return resource
def test_mixed_ironic_and_virt_network(self):
# Get tftp private network ID
net_cmd = "neutron net-show tftp"
result = self.cli.execute_cmd(net_cmd)
tftp_network = parser.details(result)
net_id = tftp_network.get("id")
# Create a ironic server and a virtual server
pubkey = self._create_keypair()
ironic_name = self._random_name("test_network_ironic_")
ironic_server = self._create_instance(
image=get_config("ironic", "image"),
flavor=get_config("ironic", "flavor"),
pubkey=pubkey,
name=ironic_name,
network=net_id,
wait_for_active=False)
virt_name = self._random_name("test_network_virt_")
virt_server = self._create_instance(image=get_config("virt", "image"),
flavor=get_config(
"virt", "flavor"),
pubkey=pubkey,
name=virt_name,
network=net_id,
wait_for_active=False)
# Wait for virtual server to go to ACTIVE
server_id = virt_server.get("id")
show_cmd = "nova show {0}".format(server_id)
virt_server = self._wait_for_status(show_cmd, "status", "ACTIVE")
self.assertEqual(virt_server.get("status"), "ACTIVE")
# Wait for ironic server to go to ACTIVE
server_id = ironic_server.get("id")
show_cmd = "nova show {0}".format(server_id)
ironic_server = self._wait_for_status(show_cmd, "status", "ACTIVE")
self.assertEqual(ironic_server.get("status"), "ACTIVE")
self.hv_id = ironic_server.get("OS-EXT-SRV-ATTR:hypervisor_hostname")
# Log onto each server and ping the other server
ironic_ip = self._get_ip_address(ironic_server)
virt_ip = self._get_ip_address(virt_server)
user = get_config("ironic", "user")
ssh_cmd = "ssh -o StrictHostKeyChecking=no -i /tmp/{0} " \
"-t {1}@{2} ping {3} -c 5".format(
pubkey, user, ironic_ip, virt_ip)
self.cli.execute_w_retry(ssh_cmd)
user = get_config("virt", "user")
ssh_cmd = "ssh -o StrictHostKeyChecking=no -i /tmp/{0} " \
"-t {1}@{2} ping {3} -c 5".format(
pubkey, user, virt_ip, ironic_ip)
self.cli.execute_w_retry(ssh_cmd)
def test_single_node_enrollment(self):
result = self.cli.execute_cmd("ironic node-create -d agent_ipmitool")
node = parser.details(result)
self.assertEqual(node.get("driver"), "agent_ipmitool")
uuid = node.get("uuid")
self.resource_deletion.append(self.delete_cmd.format(uuid))
result = self.cli.execute_cmd("ironic node-show {0}".format(uuid))
node = parser.details(result)
self.assertEqual(node.get("provision_state"), "available")
self.assertEqual(node.get("maintenance"), "False")
result = self.cli.execute_cmd("ironic node-list")
nodes = parser.listing(result)
node_listed = False
for node in nodes:
if node.get("UUID") == uuid:
node_listed = True
break
self.assertTrue(node_listed)
def _test_boot_instance(self, image, user):
# Verify image available
image_cmd = "glance image-list"
result = self.cli.execute_cmd(image_cmd)
images = parser.listing(result)
image_available = False
for available_image in images:
if available_image.get("Name") == image:
image_available = True
break
self.assertTrue(image_available,
"Image {0} not found in glance".format(image))
# Create a server
pubkey = self._create_keypair()
name = self._random_name("test_boot_instance_")
server = self._create_instance(image=image,
flavor="baremetal.general",
pubkey=pubkey,
name=name)
server_id = server.get("id")
# Verify hypervisor type of instance is ironic
self.hv_id = server.get("OS-EXT-SRV-ATTR:hypervisor_hostname")
hv_cmd = "nova hypervisor-show {0}".format(self.hv_id)
result = self.cli.execute_cmd(hv_cmd)
hypervisor = parser.details(result)
self.assertEqual(hypervisor.get("hypervisor_type"), "ironic",
"Instance not booted on ironic node")
# Verify can ssh into instance
ssh_address = self._get_ip_address(server)
ssh_cmd = "ssh -o StrictHostKeyChecking=no -i /tmp/{0} " \
"-t {1}@{2} whoami".format(pubkey, user, ssh_address)
result = self.cli.execute_w_retry(ssh_cmd)
self.assertIn(user, result)
# Perform a server action (reboot) works and verify result
reboot_cmd = "nova reboot {0}".format(server_id)
self.cli.execute_cmd(reboot_cmd)
show_cmd = "nova show {0}".format(server_id)
server = self._wait_for_status(show_cmd, "status", "REBOOT")
self.assertEqual(server.get("status"), "REBOOT")
server = self._wait_for_status(show_cmd, "status", "ACTIVE")
self.assertEqual(server.get("status"), "ACTIVE")
result = self.cli.execute_w_retry(ssh_cmd, attempts=25, delay=30)
self.assertIn(user, result)
# Delete instance and verify deletion
cmd = "nova delete {0}".format(server_id)
self.cli.execute_cmd(cmd)
self._wait_for_deletion(show_cmd)
result = self.cli.execute_cmd(show_cmd, fail_ok=True)
self.assertIn("No server with a name or ID of", result)
def test_bulk_node_enrollment(self):
# Set dynamic variables of nodes
dell_name = self._random_name("dell_")
hp_name = self._random_name("hp_")
dell_ipmi_password = get_config("ironic", "dell_ipmi_password")
hp_ipmi_password = get_config("ironic", "hp_ipmi_password")
cmd = "glance image-list | awk '/ironic-deploy.initramfs/ {print $2}'"
ramdisk = self.cli.execute_cmd(cmd)
cmd = "glance image-list | awk '/ironic-deploy.kernel/ {print $2}')"
kernel = self.cli.execute_cmd(cmd)
# Create the nodes JSON file
env = Environment(
loader=PackageLoader('ironic_integration_tests', 'templates'))
template = env.get_template('nodes.json.j2')
template_rendered = template.render(
dell_name=dell_name,
dell_ipmi_password=dell_ipmi_password,
hp_name=hp_name,
hp_ipmi_password=hp_ipmi_password,
deploy_ramdisk=ramdisk,
deploy_kernel=kernel)
f = open('nodes.json', 'w')
f.write(template_rendered)
# Create the nodes
cmd = "ironic --ironic-api-version 1.22 create nodes.json"
self.cli.execute_cmd(cmd)
cmd = "ironic node-list"
result = self.cli.execute_cmd(cmd)
nodes = parser.listing(result)
self.assertGreaterEqual(len(nodes), 2, "Nodes not created")
# Verify node properties
cmd = "ironic node-show {0}".format(dell_name)
result = self.cli.execute_cmd(cmd)
dell_node = parser.details(result)
# check some values
cmd = "ironic node-show {0}".format(hp_name)
result = self.cli.execute_cmd(cmd)
hp_node = parser.details(result)
# check some values
# Set provision states
cmd = 'ironic --ironic-api-version 1.22 node-set-provision-state ' \
'"{0}" manage'.format(dell_name)
self.cli.execute_cmd(cmd)
cmd = 'ironic --ironic-api-version 1.22 node-set-provision-state ' \
'"{0}" manage'.format(hp_name)
self.cli.execute_cmd(cmd)
time.sleep(60)
cmd = 'ironic --ironic-api-version 1.22 node-set-provision-state ' \
'"{0}" provide'.format(dell_name)
self.cli.execute_cmd(cmd)
cmd = 'ironic --ironic-api-version 1.22 node-set-provision-state ' \
'"{0}" provide'.format(hp_name)
self.cli.execute_cmd(cmd)
# Verify states of nodes
cmd = "ironic node-show {0}".format(dell_name)
result = self.cli.execute_cmd(cmd)
dell_node = parser.details(result)
self.assertEqual(dell_node.get("provision_state"), "available")
self.assertEqual(dell_node.get("maintenance"), "False")
cmd = "ironic node-show {0}".format(hp_name)
result = self.cli.execute_cmd(cmd)
hp_node = parser.details(result)
self.assertEqual(hp_node.get("provision_state"), "available")
self.assertEqual(hp_node.get("maintenance"), "False")
def test_ironic_virt_region(self):
region_cmd = "openstack region list"
result = self.cli.execute_cmd(region_cmd)
regions = parser.listing(result)
self.assertEqual(len(regions), 1, "Multiple regions deployed")
ironic_hosts = []
virtual_hosts = []
cmd = "nova hypervisor-list"
result = self.cli.execute_cmd(cmd)
hypervisors = parser.listing(result)
for hv in hypervisors:
cmd = "nova hypervisor-show {0}".format(
hv.get("Hypervisor hostname"))
result = self.cli.execute_cmd(cmd)
hypervisor = parser.details(result)
if hypervisor.get("hypervisor_type") == "ironic":
ironic_hosts.append(hypervisor.get("service_host"))
else:
virtual_hosts.append(hypervisor.get("service_host"))
self.assertGreater(len(ironic_hosts), 0, "No ironic hosts found")
self.assertGreater(len(virtual_hosts), 0, "No virtual hosts found")
pubkey = self._create_keypair()
virt_name = self._random_name("test_region_virt_")
virt_server = self._create_instance(image=get_config("virt", "image"),
flavor=get_config(
"virt", "flavor"),
pubkey=pubkey,
name=virt_name)
cmd = "nova flavor-show {0}".format(get_config("virt", "flavor"))
result = self.cli.execute_cmd(cmd)
flavor = parser.details(result)
virt_ram = flavor.get("ram")
available_ironic = None
for ironic_host in ironic_hosts:
cmd = "openstack host show {0}".format(ironic_host)
result = self.cli.execute_cmd(cmd)
projects = parser.listing(result)
total = 0
used = 0
for project in projects:
if project.get("Project") == "(total)":
total = project.get("Memory MB")
if project.get("Project") == "(used_now)":
used = project.get("Memory MB")
available_ram = int(total) - int(used)
if available_ram >= virt_ram:
available_ironic = ironic_host
break
self.assertIsNotNone(available_ironic,
"No available ironic host to attempt to migrate")
migrate_cmd = "openstack server migrate {0} --live {1}"
virt_to_ironic = migrate_cmd.format(virt_server.get("id"),
available_ironic)
result = self.cli.execute_cmd(cmd=virt_to_ironic, fail_ok=True)
self.assertIn("The supplied hypervisor type of is invalid", result)
cmd = "nova delete {0}".format(virt_name)
self.cli.execute_cmd(cmd, fail_ok=True)
ironic_name = self._random_name("test_region_ironic_")
ironic_server = self._create_instance(
image=get_config("ironic", "image"),
flavor=get_config("ironic", "flavor"),
pubkey=pubkey,
name=ironic_name)
self.hv_id = ironic_server.get("OS-EXT-SRV-ATTR:hypervisor_hostname")
cmd = "nova flavor-show {0}".format(get_config("ironic", "flavor"))
result = self.cli.execute_cmd(cmd)
flavor = parser.details(result)
ironic_ram = flavor.get("ram")
available_virt = None
for virt_host in virtual_hosts:
cmd = "openstack host show {0}".format(virt_host)
result = self.cli.execute_cmd(cmd)
projects = parser.listing(result)
total = 0
used = 0
for project in projects:
if project.get("Project") == "(total)":
total = project.get("Memory MB")
if project.get("Project") == "(used_now)":
used = project.get("Memory MB")
available_ram = int(total) - int(used)
if available_ram >= ironic_ram:
available_virt = virt_host
break
self.assertIsNotNone(
available_virt, "No available virtual host to attempt to migrate")
ironic_to_virt = migrate_cmd.format(ironic_server.get("id"),
available_virt)
result = self.cli.execute_cmd(cmd=ironic_to_virt, fail_ok=True)
self.assertIn("The supplied hypervisor type of is invalid", result)