x
/
fuel-plugin-vmware-dvs
Code Issues Proposed changes

Remove methods from openstack file. 

-remove methods add_router,
 add_subnet_to_router,
 create_network,
 create_subnet from openstack file
 and replace them by methods from os_actions
-fix D103

Change-Id: I9c370729057f3a43c9005b5347b28571ef242d51
This commit is contained in:
otsvigun 2016-03-14 16:42:09 +02:00
parent 07239bc2a5
commit 3362afb42b
6 changed files with 515 additions and 748 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/test_plan/source/test_suite_smoke.rst
View File

@ -208,6 +208,7 @@ Steps
* Controller * Controller
* Compute + CephOSD * Compute + CephOSD
* Compute + CephOSD * Compute + CephOSD
* Compute + CephOSD
* CinderVMware + ComputeVMware * CinderVMware + ComputeVMware
4. Configure interfaces on nodes. 4. Configure interfaces on nodes.
5. Configure network settings. 5. Configure network settings.

221
plugin_test/helpers/openstack.py
View File

@ -15,20 +15,23 @@ under the License.
from devops.error import TimeoutError from devops.error import TimeoutError
from devops.helpers.helpers import icmp_ping
from devops.helpers.helpers import wait from devops.helpers.helpers import wait
from fuelweb_test import logger from fuelweb_test import logger
from fuelweb_test.settings import SERVTEST_TENANT
import paramiko import paramiko
from proboscis.asserts import assert_true from proboscis.asserts import assert_true
import yaml import yaml
# timeouts
BOOT_TIMEOUT = 300
def get_defaults(): def get_defaults():
"""Get default parameters from config.yaml."""
with open('plugin_test/helpers/config.yaml') as config: with open('plugin_test/helpers/config.yaml') as config:
defaults = yaml.load(config.read()) defaults = yaml.load(config.read())
logger.info(''.format(defaults)) logger.info(''.format(defaults))
@ -43,7 +46,7 @@ instance_creds = (
def verify_instance_state(os_conn, instances=None, expected_state='ACTIVE', def verify_instance_state(os_conn, instances=None, expected_state='ACTIVE',
boot_timeout=300): boot_timeout=BOOT_TIMEOUT):
"""Verify that current state of each instance/s is expected. """Verify that current state of each instance/s is expected.
:param os_conn: type object, openstack :param os_conn: type object, openstack
@ -51,7 +54,6 @@ def verify_instance_state(os_conn, instances=None, expected_state='ACTIVE',
:param expected_state: type string, expected state of instance :param expected_state: type string, expected state of instance
:param boot_timeout: type int, time in seconds to build instance :param boot_timeout: type int, time in seconds to build instance
""" """
boot_timeout = 300
if not instances: if not instances:
instances = os_conn.nova.servers.list() instances = os_conn.nova.servers.list()
for instance in instances: for instance in instances:
@ -59,7 +61,7 @@ def verify_instance_state(os_conn, instances=None, expected_state='ACTIVE',
wait( wait(
lambda: lambda:
os_conn.get_instance_detail(instance).status == expected_state, os_conn.get_instance_detail(instance).status == expected_state,
timeout=boot_timeout) timeout=BOOT_TIMEOUT)
except TimeoutError: except TimeoutError:
current_state = os_conn.get_instance_detail(instance).status current_state = os_conn.get_instance_detail(instance).status
assert_true( assert_true(
@ -102,57 +104,76 @@ def create_instances(os_conn, nics, vm_count=1,
return instances return instances
def check_connection_vms(os_conn, srv_list, remote, command='pingv4', def check_connection_vms(os_conn, fip, remote, command='pingv4',
result_of_command=0, result_of_command=0,
destination_ip=None): destination_ip=None):
"""Check network connectivity between instances. """Check network connectivity between instances.
:param os_conn: type object, openstack :param os_conn: type object, openstack
:param srv_list: type list, instances :param fip: type list, floating ips of instances
:param packets: type int, packets count of icmp reply
:param remote: SSHClient to primary controller :param remote: SSHClient to primary controller
:param destination_ip: type list, remote destination ip to :param destination_ip: type list, remote destination ip to
check by ping check by ping, by default is None
:param command: type string, key from dictionary 'commands'
by default is 'pingv4'
:param result_of_command: type interger, exite code of command execution
by default is 0
""" """
commands = { commands = {
"pingv4": "ping -c 5 {}", "pingv4": "ping -c 5 {}",
"pingv6": "ping6 -c 5 {}", "pingv6": "ping6 -c 5 {}",
"arping": "sudo arping -I eth0 {}"} "arping": "sudo arping -I eth0 {}"}
for srv in srv_list: if not destination_ip:
addresses = srv.addresses[srv.addresses.keys()[0]] ip_pair = [
fip = [ (ip_1, ip_2)
add['addr'] for ip_1 in fip
for add in addresses for ip_2 in fip
if add['OS-EXT-IPS:type'] == 'floating'][0] if ip_1 != ip_2]
else:
ip_pair = [
(ip_1, ip_2)
for ip_1 in fip
for ip_2 in destination_ip]
for ips in ip_pair:
logger.info("Connect to VM {0}".format(ips[0]))
command_result = os_conn.execute_through_host(
remote, ips[0],
commands[command].format(ips[1]), instance_creds)
if not destination_ip: assert_true(
destination_ip = [s.networks[s.networks.keys()[0]][0] result_of_command == command_result['exit_code'],
for s in srv_list if s != srv] " Command {0} from Vm {1},"
" executed with code {2}".format(
commands[command].format(ips[1]),
ips[0], command_result)
)
for ip in destination_ip:
if ip != srv.networks[srv.networks.keys()[0]][0]: def create_and_assign_floating_ips(os_conn, instances_list):
logger.info("Connect to VM {0}".format(fip)) """Create Vms on available hypervisors.
command_result = os_conn.execute_through_host(
remote, fip, :param os_conn: type object, openstack
commands[command].format(ip), instance_creds) :param instances_list: type list, instances
logger.info("Command result: \n" """
"{0}\n" fips = []
"{1}\n" for instance in instances_list:
"exit_code={2}" ip = os_conn.assign_floating_ip(
.format(command_result['stdout'], instance).ip
command_result['stderr'], fips.append(ip)
command_result['exit_code'])) wait(lambda: icmp_ping(ip), timeout=60 * 3, interval=5)
assert_true( return fips
result_of_command == command_result['exit_code'],
" Command {0} from Vm {1},"
" executed with code {2}".format(
commands[command].format(ip),
fip, command_result)
)
def get_ssh_connection(ip, username, userpassword, timeout=30, port=22): def get_ssh_connection(ip, username, userpassword, timeout=30, port=22):
"""Get ssh to host.
:param ip: string, host ip to connect to
:param username: string, a username to use for authentication
:param userpassword: string, a password to use for authentication
:param timeout: timeout (in seconds) for the TCP connection
:param port: host port to connect to
"""
ssh = paramiko.SSHClient() ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy()) ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect( ssh.connect(
@ -162,34 +183,6 @@ def get_ssh_connection(ip, username, userpassword, timeout=30, port=22):
return ssh return ssh
def check_ssh_between_instances(instance1_ip, instance2_ip):
"""Check ssh conection between instances.
:param instance1: string, instance ip connect from
:param instance2: string, instance ip connect to
"""
ssh = get_ssh_connection(instance1_ip, instance_creds[0],
instance_creds[1], timeout=30)
interm_transp = ssh.get_transport()
logger.info("Opening channel to VM")
logger.info('{0}, {1}'.format(instance2_ip, instance1_ip))
interm_chan = interm_transp.open_channel('direct-tcpip',
(instance2_ip, 22),
(instance1_ip, 0))
logger.info("Opening paramiko transport")
transport = paramiko.Transport(interm_chan)
logger.info("Starting client")
transport.start_client()
logger.info("Passing authentication to VM")
transport.auth_password(
instance_creds[0], instance_creds[1])
channel = transport.open_session()
assert_true(channel.send_ready())
logger.debug("Closing channel")
channel.close()
def remote_execute_command(instance1_ip, instance2_ip, command): def remote_execute_command(instance1_ip, instance2_ip, command):
"""Check execute remote command. """Check execute remote command.
@ -236,92 +229,8 @@ def remote_execute_command(instance1_ip, instance2_ip, command):
return result return result
def create_and_assign_floating_ip(os_conn, srv_list=None,
ext_net=None, tenant_id=None):
"""Create Vms on available hypervisors.
:param os_conn: type object, openstack
:param srv_list: type list, objects of created instances
:param ext_net: type object, neutron external network
:param tenant_id: type string, tenant id
"""
if not ext_net:
ext_net = [net for net
in os_conn.neutron.list_networks()["networks"]
if net['name'] == external_net_name][0]
if not tenant_id:
tenant_id = os_conn.get_tenant(SERVTEST_TENANT).id
if not srv_list:
srv_list = os_conn.get_servers()
for srv in srv_list:
fip = os_conn.neutron.create_floatingip(
{'floatingip': {
'floating_network_id': ext_net['id'],
'tenant_id': tenant_id}})
os_conn.nova.servers.add_floating_ip(
srv, fip['floatingip']['floating_ip_address']
)
def add_router(os_conn, router_name, ext_net_name=external_net_name,
tenant_name=SERVTEST_TENANT):
"""Create router with gateway.
:param router_name: type string
:param ext_net_name: type string
:param tenant_name: type string
"""
ext_net = [net for net
in os_conn.neutron.list_networks()["networks"]
if net['name'] == ext_net_name][0]
gateway = {"network_id": ext_net["id"],
"enable_snat": True
}
tenant_id = os_conn.get_tenant(tenant_name).id
router_param = {'router': {'name': router_name,
'external_gateway_info': gateway,
'tenant_id': tenant_id}}
router = os_conn.neutron.create_router(body=router_param)['router']
return router
def add_subnet_to_router(os_conn, router_id, sub_id):
os_conn.neutron.add_interface_router(
router_id,
{'subnet_id': sub_id}
)
def create_network(os_conn, name,
tenant_name=SERVTEST_TENANT):
tenant_id = os_conn.get_tenant(tenant_name).id
net_body = {"network": {"name": name,
"tenant_id": tenant_id
}
}
network = os_conn.neutron.create_network(net_body)['network']
return network
def create_subnet(os_conn, network,
cidr, tenant_name=SERVTEST_TENANT):
tenant_id = os_conn.get_tenant(tenant_name).id
subnet_body = {"subnet": {"network_id": network['id'],
"ip_version": 4,
"cidr": cidr,
"name": 'subnet_{}'.format(
network['name'][-1]),
"tenant_id": tenant_id
}
}
subnet = os_conn.neutron.create_subnet(subnet_body)['subnet']
return subnet
def get_role(os_conn, role_name): def get_role(os_conn, role_name):
"""Get role by name."""
role_list = os_conn.keystone.roles.list() role_list = os_conn.keystone.roles.list()
for role in role_list: for role in role_list:
if role.name == role_name: if role.name == role_name:
@ -330,6 +239,13 @@ def get_role(os_conn, role_name):
def add_role_to_user(os_conn, user_name, role_name, tenant_name): def add_role_to_user(os_conn, user_name, role_name, tenant_name):
"""Assign role to user.
:param os_conn: type object
:param user_name: type string,
:param role_name: type string
:param tenant_name: type string
"""
tenant_id = os_conn.get_tenant(tenant_name).id tenant_id = os_conn.get_tenant(tenant_name).id
user_id = os_conn.get_user(user_name).id user_id = os_conn.get_user(user_name).id
role_id = get_role(os_conn, role_name).id role_id = get_role(os_conn, role_name).id
@ -362,7 +278,6 @@ def create_volume(os_conn, availability_zone, size=1,
:param expected_state: type string, expected state of instance :param expected_state: type string, expected state of instance
:param size: type int, size of volume :param size: type int, size of volume
""" """
boot_timeout = 300
images_list = os_conn.nova.images.list() images_list = os_conn.nova.images.list()
image = [ image = [
image for image image for image
@ -372,7 +287,7 @@ def create_volume(os_conn, availability_zone, size=1,
size=size, imageRef=image.id, availability_zone=availability_zone) size=size, imageRef=image.id, availability_zone=availability_zone)
wait( wait(
lambda: os_conn.cinder.volumes.get(volume.id).status == expected_state, lambda: os_conn.cinder.volumes.get(volume.id).status == expected_state,
timeout=boot_timeout) timeout=BOOT_TIMEOUT)
logger.info("Created volume: '{0}', parent image: '{1}'" logger.info("Created volume: '{0}', parent image: '{1}'"
.format(volume.id, image.id)) .format(volume.id, image.id))
return volume return volume

383
plugin_test/tests/test_plugin_vmware_dvs_destructive.py
View File

@ -31,6 +31,7 @@ from fuelweb_test.settings import SERVTEST_USERNAME
from fuelweb_test.tests.base_test_case import SetupEnvironment from fuelweb_test.tests.base_test_case import SetupEnvironment
from fuelweb_test.tests.base_test_case import TestBasic from fuelweb_test.tests.base_test_case import TestBasic
from tests.test_plugin_vmware_dvs_system import TestDVSSystem
from helpers import openstack from helpers import openstack
from helpers import plugin from helpers import plugin
@ -54,84 +55,30 @@ class TestDVSDestructive(TestBasic):
"""Get node by name.""" """Get node by name."""
return self.fuel_web.get_nailgun_node_by_name(name_node)['hostname'] return self.fuel_web.get_nailgun_node_by_name(name_node)['hostname']
# constants
cmds = ['nova-manage service list | grep vcenter-vmcluster1',
'nova-manage service list | grep vcenter-vmcluster2']
net_data = [{'net_1': '192.168.112.0/24'},
{'net_2': '192.168.113.0/24'}]
# defaults # defaults
inter_net_name = openstack.get_defaults()['networks']['internal']['name'] inter_net_name = openstack.get_defaults()['networks']['internal']['name']
ext_net_name = openstack.get_defaults()['networks']['floating']['name']
@test(depends_on=[SetupEnvironment.prepare_slaves_5], @test(depends_on=[TestDVSSystem.dvs_vcenter_systest_setup],
groups=["dvs_vcenter_destructive_setup", "dvs_vcenter_plugin"])
@log_snapshot_after_test
def dvs_vcenter_destructive_setup(self):
"""Deploy cluster with plugin and vmware datastore backend.
Scenario:
1. Upload plugins to the master node
2. Install plugin.
3. Create cluster with vcenter.
4. Add 1 node with controller role.
5. Add 1 node with compute role.
6. Add 1 node with compute-vmware role.
7. Deploy the cluster.
8. Run OSTF.
Duration: 1.8 hours
"""
self.env.revert_snapshot("ready_with_5_slaves")
plugin.install_dvs_plugin(
self.env.d_env.get_admin_remote())
# Configure cluster with 2 vcenter clusters and vcenter glance
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=DEPLOYMENT_MODE,
settings={
"net_provider": 'neutron',
"net_segment_type": NEUTRON_SEGMENT_TYPE,
'images_vcenter': True
}
)
plugin.enable_plugin(cluster_id, self.fuel_web)
# Assign role to node
self.fuel_web.update_nodes(
cluster_id,
{'slave-01': ['controller'],
'slave-02': ['compute-vmware'],
'slave-03': ['compute']
}
)
# Configure VMWare vCenter settings
target_node_2 = self.node_name('slave-02')
self.fuel_web.vcenter_configure(
cluster_id,
target_node_2=target_node_2,
multiclusters=True,
vc_glance=True
)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke'])
self.env.make_snapshot("dvs_vcenter_destructive_setup", is_make=True)
@test(depends_on=[dvs_vcenter_destructive_setup],
groups=["dvs_vcenter_uninstall", 'dvs_vcenter_system']) groups=["dvs_vcenter_uninstall", 'dvs_vcenter_system'])
@log_snapshot_after_test @log_snapshot_after_test
def dvs_vcenter_uninstall(self): def dvs_vcenter_uninstall(self):
"""Negative uninstall of Fuel DVS plugin with deployed environment. """Negative uninstall of Fuel DVS plugin with deployed environment.
Scenario: Scenario:
1. Revert snapshot to dvs_vcenter_destructive_setup. 1. Revert snapshot to dvs_vcenter_systest_setup.
2. Try to uninstall dvs plugin. 2. Try to uninstall dvs plugin.
Duration: 1.8 hours Duration: 1.8 hours
""" """
self.env.revert_snapshot("dvs_vcenter_destructive_setup") self.env.revert_snapshot("dvs_vcenter_systest_setup")
# Try to uninstall dvs plugin # Try to uninstall dvs plugin
cmd = 'fuel plugins --remove {0}=={1}'.format( cmd = 'fuel plugins --remove {0}=={1}'.format(
@ -148,8 +95,8 @@ class TestDVSDestructive(TestBasic):
"Plugin is removed {}".format(plugin.plugin_name) "Plugin is removed {}".format(plugin.plugin_name)
) )
@test(depends_on=[dvs_vcenter_destructive_setup], @test(depends_on=[TestDVSSystem.dvs_vcenter_systest_setup],
groups=["dvs_vcenter_bind_port", "dvs_vcenter_destructive_setup"]) groups=["dvs_vcenter_bind_port"])
@log_snapshot_after_test @log_snapshot_after_test
def dvs_vcenter_bind_port(self): def dvs_vcenter_bind_port(self):
"""Check abilities to bind port on DVS to VM, disable/enable this port. """Check abilities to bind port on DVS to VM, disable/enable this port.
@ -171,7 +118,7 @@ class TestDVSDestructive(TestBasic):
Duration: 1,5 hours Duration: 1,5 hours
""" """
self.env.revert_snapshot("dvs_vcenter_destructive_setup") self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster() cluster_id = self.fuel_web.get_last_created_cluster()
@ -185,74 +132,86 @@ class TestDVSDestructive(TestBasic):
# create security group with rules for ssh and ping # create security group with rules for ssh and ping
security_group = os_conn.create_sec_group_for_ssh() security_group = os_conn.create_sec_group_for_ssh()
logger.info("Create non default network with subnet.")
logger.info('Create network {}'.format(self.net_data[0].keys()[0]))
network = os_conn.create_network(
network_name=self.net_data[0].keys()[0])['network']
subnet = os_conn.create_subnet(
subnet_name=network['name'],
network_id=network['id'],
cidr=self.net_data[0][self.net_data[0].keys()[0]])
logger.info("Check that network are created.")
assert_true(
os_conn.get_network(network['name'])['id'] == network['id']
)
logger.info("Add net_1 to default router")
router = os_conn.get_router(os_conn.get_network(self.ext_net_name))
os_conn.add_router_interface(
router_id=router["id"],
subnet_id=subnet["id"])
# Launch instance VM_1 and VM_2 # Launch instance VM_1 and VM_2
network = os_conn.nova.networks.find(label=self.inter_net_name) instances = openstack.create_instances(
openstack.create_instances( os_conn=os_conn, nics=[{'net-id': network['id']}], vm_count=1,
os_conn=os_conn, nics=[{'net-id': network.id}], vm_count=1,
security_groups=[security_group.name] security_groups=[security_group.name]
) )
openstack.verify_instance_state(os_conn) openstack.verify_instance_state(os_conn)
openstack.create_and_assign_floating_ip(os_conn=os_conn)
time.sleep(30) # need time to apply updates
# Bind sub_net ports of instances
ports = os_conn.neutron.list_ports()['ports'] ports = os_conn.neutron.list_ports()['ports']
srv_list = os_conn.get_servers() floating_ip = openstack.create_and_assign_floating_ips(
for srv in srv_list: os_conn, instances)
srv_addr = srv.networks[srv.networks.keys()[0]][0] instance_ports = []
for instance in instances:
instance_addr = os_conn.get_nova_instance_ip(
instance, net_name=network['name'])
for port in ports: for port in ports:
port_addr = port['fixed_ips'][0]['ip_address'] port_addr = port['fixed_ips'][0]['ip_address']
if srv_addr == port_addr: if instance_addr == port_addr:
os_conn.neutron.update_port( instance_ports.append(port)
port['id'], {'port': {'admin_state_up': False}} for port in instance_ports:
) os_conn.neutron.update_port(
port['id'], {'port': {'admin_state_up': False}}
)
srv_list = os_conn.get_servers() controller = self.fuel_web.get_nailgun_primary_node(
# Verify that not connection to instances
primary_controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0] self.env.d_env.nodes().slaves[0]
) )
ssh_controller = self.fuel_web.get_ssh_for_node( with self.fuel_web.get_ssh_for_node(controller.name) as ssh_controller:
primary_controller.name # Verify that not connection to instances
) try:
openstack.check_connection_vms(
os_conn, floating_ip, remote=ssh_controller,
command='pingv4')
except Exception as e:
logger.info(str(e))
try: # Enable sub_net ports of instances
for port in instance_ports:
os_conn.neutron.update_port(
port['id'], {'port': {'admin_state_up': True}}
)
instance.reboot()
wait(
lambda:
os_conn.get_instance_detail(instance).status == "ACTIVE",
timeout=300)
time.sleep(60) # need time after reboot to get ip by instance
# Verify that instances should communicate between each other.
# Send icmp ping between instances
openstack.check_connection_vms( openstack.check_connection_vms(
os_conn=os_conn, srv_list=srv_list, remote=ssh_controller) os_conn, floating_ip, remote=ssh_controller,
except Exception as e: command='pingv4')
logger.info(str(e))
# Enable sub_net ports of instances
for srv in srv_list:
srv_addr = srv.networks[srv.networks.keys()[0]][0]
for port in ports:
port_addr = port['fixed_ips'][0]['ip_address']
if srv_addr == port_addr:
os_conn.neutron.update_port(
port['id'], {'port': {'admin_state_up': True}}
)
srv_list = os_conn.get_servers()
for srv in srv_list:
srv.reboot()
wait(
lambda:
os_conn.get_instance_detail(srv).status == "ACTIVE",
timeout=300)
time.sleep(60) # need time after reboot to get ip by instance
# Verify that instances should communicate between each other.
# Send icmp ping between instances
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list,
remote=ssh_controller)
@test(depends_on=[SetupEnvironment.prepare_slaves_5], @test(depends_on=[SetupEnvironment.prepare_slaves_5],
groups=["dvs_vcenter_reset_controller", 'dvs_vcenter_system']) groups=["dvs_destructive_setup_2", 'dvs_vcenter_system'])
@log_snapshot_after_test @log_snapshot_after_test
def dvs_vcenter_reset_controller(self): def dvs_destructive_setup_2(self):
"""Verify that vmclusters should be migrate after reset controller. """Verify that vmclusters should be migrate after reset controller.
Scenario: Scenario:
@ -263,12 +222,6 @@ class TestDVSDestructive(TestBasic):
5. Add 2 node with compute role. 5. Add 2 node with compute role.
6. Deploy the cluster. 6. Deploy the cluster.
7. Launch instances. 7. Launch instances.
8. Verify connection between instances. Send ping,
check that ping get reply
9. Reset controller.
10. Check that vmclusters should be migrate to another controller.
11. Verify connection between instances.
Send ping, check that ping get reply
Duration: 1.8 hours Duration: 1.8 hours
@ -316,156 +269,130 @@ class TestDVSDestructive(TestBasic):
security_group = os_conn.create_sec_group_for_ssh() security_group = os_conn.create_sec_group_for_ssh()
network = os_conn.nova.networks.find(label=self.inter_net_name) network = os_conn.nova.networks.find(label=self.inter_net_name)
openstack.create_instances( instances = openstack.create_instances(
os_conn=os_conn, nics=[{'net-id': network.id}], vm_count=1, os_conn=os_conn, nics=[{'net-id': network.id}], vm_count=1,
security_groups=[security_group.name] security_groups=[security_group.name]
) )
openstack.verify_instance_state(os_conn) openstack.verify_instance_state(os_conn)
for instance in instances:
os_conn.assign_floating_ip(instance)
self.env.make_snapshot("dvs_destructive_setup_2", is_make=True)
@test(depends_on=[dvs_destructive_setup_2],
groups=["dvs_vcenter_reset_controller", 'dvs_vcenter_system'])
@log_snapshot_after_test
def dvs_vcenter_reset_controller(self):
"""Verify that vmclusters should be migrate after reset controller.
Scenario:
1. Revert to 'dvs_destructive_setup_2' snapshot.
2. Verify connection between instances. Send ping,
check that ping get reply
3. Reset controller.
4. Check that vmclusters should be migrate to another controller.
5. Verify connection between instances.
Send ping, check that ping get reply
Duration: 1.8 hours
"""
self.env.revert_snapshot("dvs_destructive_setup_2")
cluster_id = self.fuel_web.get_last_created_cluster()
os_ip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions(
os_ip, SERVTEST_USERNAME,
SERVTEST_PASSWORD,
SERVTEST_TENANT)
# Verify connection between instances. # Verify connection between instances.
# Send ping Check that ping get reply. # Send ping Check that ping get reply.
openstack.create_and_assign_floating_ip(os_conn=os_conn)
srv_list = os_conn.get_servers() srv_list = os_conn.get_servers()
primary_controller = self.fuel_web.get_nailgun_primary_node( floating_ip = []
for srv in srv_list:
floating_ip.append(os_conn.get_nova_instance_ip(
srv, net_name=self.inter_net_name, type='floating'))
controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0] self.env.d_env.nodes().slaves[0]
) )
ssh_controller = self.fuel_web.get_ssh_for_node( with self.fuel_web.get_ssh_for_node(controller.name) as ssh_control:
primary_controller.name openstack.check_service(ssh=ssh_control, commands=self.cmds)
) openstack.check_connection_vms(
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list, os_conn, floating_ip, remote=ssh_control,
remote=ssh_controller) command='pingv4')
cmds = ['nova-manage service list | grep vcenter-vmcluster1', self.fuel_web.cold_restart_nodes(
'nova-manage service list | grep vcenter-vmcluster2'] [self.fuel_web.environment.d_env.get_node(name=controller.name)],
wait_offline=True, wait_online=True,
wait_after_destroy=300)
openstack.check_service(ssh=ssh_controller, commands=cmds) controller = self.fuel_web.get_nailgun_primary_node(
self.fuel_web.warm_restart_nodes(
[self.fuel_web.environment.d_env.get_node(
name=primary_controller.name)])
primary_controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[1] self.env.d_env.nodes().slaves[1]
) )
ssh_controller = self.fuel_web.get_ssh_for_node(
primary_controller.name
)
openstack.check_service(ssh=ssh_controller, commands=cmds)
# Verify connection between instances. # Verify connection between instances.
# Send ping Check that ping get reply. # Send ping Check that ping get reply.
srv_list = os_conn.get_servers() with self.fuel_web.get_ssh_for_node(controller.name) as ssh_control:
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list, openstack.check_service(ssh=ssh_control, commands=self.cmds)
remote=ssh_controller) openstack.check_connection_vms(
os_conn, floating_ip, remote=ssh_control,
command='pingv4')
@test(depends_on=[SetupEnvironment.prepare_slaves_5], @test(depends_on=[dvs_destructive_setup_2],
groups=["dvs_vcenter_shutdown_controller", 'dvs_vcenter_system']) groups=["dvs_vcenter_shutdown_controller", 'dvs_vcenter_system'])
@log_snapshot_after_test @log_snapshot_after_test
def dvs_vcenter_shutdown_controller(self): def dvs_vcenter_shutdown_controller(self):
"""Verify that vmclusters should be migrate after shutdown controller. """Verify that vmclusters should be migrate after shutdown controller.
Scenario: Scenario:
1. Upload plugins to the master node 1. Revert to 'dvs_destructive_setup_2' snapshot.
2. Install plugin. 2. Verify connection between instances. Send ping,
3. Create cluster with vcenter.
4. Add 3 node with controller role.
5. Add 2 node with compute role.
6. Deploy the cluster.
7. Launch instances.
8. Verify connection between instances. Send ping,
check that ping get reply. check that ping get reply.
9. Shutdown controller. 3. Shutdown controller.
10. Check that vmclusters should be migrate to another controller. 4. Check that vmclusters should be migrate to another controller.
11. Verify connection between instances. 5. Verify connection between instances.
Send ping, check that ping get reply Send ping, check that ping get reply
Duration: 1.8 hours Duration: 1.8 hours
""" """
self.env.revert_snapshot("ready_with_5_slaves") self.env.revert_snapshot("dvs_destructive_setup_2")
plugin.install_dvs_plugin(
self.env.d_env.get_admin_remote())
# Configure cluster with 2 vcenter clusters and vcenter glance
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=DEPLOYMENT_MODE,
settings={
"net_provider": 'neutron',
"net_segment_type": NEUTRON_SEGMENT_TYPE
}
)
plugin.enable_plugin(cluster_id, self.fuel_web)
# Assign role to node
self.fuel_web.update_nodes(
cluster_id,
{'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['compute']}
)
# Configure VMWare vCenter settings
self.fuel_web.vcenter_configure(cluster_id, multiclusters=True)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke'])
cluster_id = self.fuel_web.get_last_created_cluster()
os_ip = self.fuel_web.get_public_vip(cluster_id) os_ip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions( os_conn = os_actions.OpenStackActions(
os_ip, SERVTEST_USERNAME, os_ip, SERVTEST_USERNAME,
SERVTEST_PASSWORD, SERVTEST_PASSWORD,
SERVTEST_TENANT) SERVTEST_TENANT)
# create security group with rules for ssh and ping
security_group = os_conn.create_sec_group_for_ssh()
network = os_conn.nova.networks.find(label=self.inter_net_name)
openstack.create_instances(
os_conn=os_conn, nics=[{'net-id': network.id}], vm_count=1,
security_groups=[security_group.name])
openstack.verify_instance_state(os_conn)
# Verify connection between instances. # Verify connection between instances.
# Send ping, check that ping get reply. # Send ping, check that ping get reply.
openstack.create_and_assign_floating_ip(os_conn=os_conn)
srv_list = os_conn.get_servers() srv_list = os_conn.get_servers()
floating_ip = []
controlers = self.fuel_web.get_devops_nodes_by_nailgun_nodes( for srv in srv_list:
floating_ip.append(os_conn.get_nova_instance_ip(
srv, net_name=self.inter_net_name, type='floating'))
controllers = self.fuel_web.get_devops_nodes_by_nailgun_nodes(
self.fuel_web.get_nailgun_cluster_nodes_by_roles( self.fuel_web.get_nailgun_cluster_nodes_by_roles(
cluster_id=cluster_id, cluster_id=cluster_id,
roles=['controller'])) roles=['controller']))
ssh_controller = self.fuel_web.get_ssh_for_node(controlers[0].name) with self.fuel_web.get_ssh_for_node(controllers[0].name) as ssh_contr:
openstack.check_connection_vms( openstack.check_service(ssh=ssh_contr, commands=self.cmds)
os_conn=os_conn, openstack.check_connection_vms(
srv_list=srv_list, os_conn, floating_ip, remote=ssh_contr,
remote=ssh_controller command='pingv4')
)
cmds = ['nova-manage service list | grep vcenter-vmcluster1',
'nova-manage service list | grep vcenter-vmcluster2']
openstack.check_service(ssh=ssh_controller, commands=cmds)
self.fuel_web.warm_shutdown_nodes( self.fuel_web.warm_shutdown_nodes(
[self.fuel_web.environment.d_env.get_node( [self.fuel_web.environment.d_env.get_node(
name=controlers[0].name)]) name=controllers[0].name)])
ssh_controller = self.fuel_web.get_ssh_for_node(
controlers[1].name)
openstack.check_service(ssh=ssh_controller, commands=cmds)
# Verify connection between instances. # Verify connection between instances.
# Send ping Check that ping get reply. # Send ping Check that ping get reply.
srv_list = os_conn.get_servers() with self.fuel_web.get_ssh_for_node(controllers[1].name) as ssh_contr:
openstack.check_connection_vms( openstack.check_service(ssh=ssh_contr, commands=self.cmds)
os_conn=os_conn, srv_list=srv_list, openstack.check_connection_vms(
remote=ssh_controller os_conn, floating_ip, remote=ssh_contr,
) command='pingv4')

89
plugin_test/tests/test_plugin_vmware_dvs_maintenance.py
View File

@ -21,17 +21,14 @@ from fuelweb_test.helpers import os_actions
from fuelweb_test.helpers.decorators import log_snapshot_after_test from fuelweb_test.helpers.decorators import log_snapshot_after_test
from fuelweb_test.settings import DEPLOYMENT_MODE
from fuelweb_test.settings import NEUTRON_SEGMENT_TYPE
from fuelweb_test.settings import SERVTEST_PASSWORD from fuelweb_test.settings import SERVTEST_PASSWORD
from fuelweb_test.settings import SERVTEST_TENANT from fuelweb_test.settings import SERVTEST_TENANT
from fuelweb_test.settings import SERVTEST_USERNAME from fuelweb_test.settings import SERVTEST_USERNAME
from fuelweb_test.tests.base_test_case import SetupEnvironment
from fuelweb_test.tests.base_test_case import TestBasic from fuelweb_test.tests.base_test_case import TestBasic
from tests.test_plugin_vmware_dvs_smoke import TestDVSSmoke
from helpers import openstack from helpers import openstack
from helpers import plugin
from proboscis import test from proboscis import test
@ -54,7 +51,7 @@ class TestDVSMaintenance(TestBasic):
"""Get node by name.""" """Get node by name."""
return self.fuel_web.get_nailgun_node_by_name(name_node)['hostname'] return self.fuel_web.get_nailgun_node_by_name(name_node)['hostname']
@test(depends_on=[SetupEnvironment.prepare_slaves_9], @test(depends_on=[TestDVSSmoke.dvs_vcenter_bvt],
groups=["dvs_regression"]) groups=["dvs_regression"])
@log_snapshot_after_test @log_snapshot_after_test
def dvs_regression(self): def dvs_regression(self):
@ -64,9 +61,9 @@ class TestDVSMaintenance(TestBasic):
1. Upload plugins to the master node 1. Upload plugins to the master node
2. Install plugin. 2. Install plugin.
3. Create cluster with vcenter. 3. Create cluster with vcenter.
4. Add 3 node with controller+mongo+cinder-vmware role. 4. Add 3 node with controller role.
5. Add 2 node with compute role. 5. Add 2 node with compute + ceph role.
6. Add 1 node with compute-vmware role. 6. Add 1 node with compute-vmware + cinder vmware role.
7. Deploy the cluster. 7. Deploy the cluster.
8. Run OSTF. 8. Run OSTF.
9. Create non default network. 9. Create non default network.
@ -77,69 +74,38 @@ class TestDVSMaintenance(TestBasic):
Duration: 1.8 hours Duration: 1.8 hours
""" """
self.env.revert_snapshot("ready_with_9_slaves") self.env.revert_snapshot("dvs_bvt")
plugin.install_dvs_plugin(self.env.d_env.get_admin_remote())
# Configure cluster with 2 vcenter clusters and vcenter glance cluster_id = self.fuel_web.get_last_created_cluster()
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=DEPLOYMENT_MODE,
settings={
"net_provider": 'neutron',
"net_segment_type": NEUTRON_SEGMENT_TYPE,
"images_vcenter": True
}
)
plugin.enable_plugin(cluster_id, self.fuel_web)
# Assign role to node
self.fuel_web.update_nodes(
cluster_id,
{'slave-01': ['controller', 'mongo', 'cinder-vmware'],
'slave-02': ['controller', 'mongo', 'cinder-vmware'],
'slave-03': ['controller', 'mongo', 'cinder-vmware'],
'slave-04': ['compute'],
'slave-05': ['compute'],
'slave-06': ['compute-vmware']}
)
# Configure VMWare vCenter settings
target_node_2 = self.node_name('slave-06')
self.fuel_web.vcenter_configure(
cluster_id,
target_node_2=target_node_2,
multiclusters=True,
vc_glance=True
)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke', 'tests_platform'])
os_ip = self.fuel_web.get_public_vip(cluster_id) os_ip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions( os_conn = os_actions.OpenStackActions(
os_ip, SERVTEST_USERNAME, os_ip, SERVTEST_USERNAME,
SERVTEST_PASSWORD, SERVTEST_PASSWORD,
SERVTEST_TENANT) SERVTEST_TENANT)
tenant = os_conn.get_tenant(SERVTEST_TENANT)
# Create non default network with subnet. # Create non default network with subnet.
logger.info('Create network {}'.format(self.net_data[0].keys()[0])) logger.info('Create network {}'.format(self.net_data[0].keys()[0]))
network = openstack.create_network( network = os_conn.create_network(
os_conn, network_name=self.net_data[0].keys()[0],
self.net_data[0].keys()[0], tenant_id=tenant.id)['network']
tenant_name=SERVTEST_TENANT
) subnet = os_conn.create_subnet(
logger.info('Create subnet {}'.format(self.net_data[0].keys()[0])) subnet_name=network['name'],
subnet = openstack.create_subnet( network_id=network['id'],
os_conn, cidr=self.net_data[0][self.net_data[0].keys()[0]],
network, ip_version=4)
self.net_data[0][self.net_data[0].keys()[0]],
tenant_name=SERVTEST_TENANT
)
# Check that network are created. # Check that network are created.
assert_true( assert_true(
os_conn.get_network(network['name'])['id'] == network['id'] os_conn.get_network(network['name'])['id'] == network['id']
) )
# Add net_1 to default router # Add net_1 to default router
router = os_conn.get_router(os_conn.get_network(self.ext_net_name)) router = os_conn.get_router(os_conn.get_network(self.ext_net_name))
openstack.add_subnet_to_router( os_conn.add_router_interface(
os_conn, router_id=router["id"],
router['id'], subnet['id']) subnet_id=subnet["id"])
# Launch instance 2 VMs of vcenter and 2 VMs of nova # Launch instance 2 VMs of vcenter and 2 VMs of nova
# in the tenant network net_01 # in the tenant network net_01
openstack.create_instances( openstack.create_instances(
@ -149,11 +115,11 @@ class TestDVSMaintenance(TestBasic):
# Launch instance 2 VMs of vcenter and 2 VMs of nova # Launch instance 2 VMs of vcenter and 2 VMs of nova
# in the default network # in the default network
network = os_conn.nova.networks.find(label=self.inter_net_name) network = os_conn.nova.networks.find(label=self.inter_net_name)
openstack.create_instances( instances = openstack.create_instances(
os_conn=os_conn, vm_count=1, os_conn=os_conn, vm_count=1,
nics=[{'net-id': network.id}]) nics=[{'net-id': network.id}])
openstack.verify_instance_state(os_conn) openstack.verify_instance_state(os_conn)
openstack.create_and_assign_floating_ip(os_conn=os_conn)
# Create security groups SG_1 to allow ICMP traffic. # Create security groups SG_1 to allow ICMP traffic.
# Add Ingress rule for ICMP protocol to SG_1 # Add Ingress rule for ICMP protocol to SG_1
# Create security groups SG_2 to allow TCP traffic 22 port. # Create security groups SG_2 to allow TCP traffic 22 port.
@ -192,11 +158,12 @@ class TestDVSMaintenance(TestBasic):
srv.add_security_group(sg1.id) srv.add_security_group(sg1.id)
srv.add_security_group(sg2.id) srv.add_security_group(sg2.id)
time.sleep(20) # need wait to update rules on dvs time.sleep(20) # need wait to update rules on dvs
fip = openstack.create_and_assign_floating_ips(os_conn, instances)
# Check ping between VMs # Check ping between VMs
controller = self.fuel_web.get_nailgun_primary_node( controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0] self.env.d_env.nodes().slaves[0]
) )
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_controller: with self.fuel_web.get_ssh_for_node(controller.name) as ssh_controller:
openstack.check_connection_vms( openstack.check_connection_vms(
os_conn=os_conn, srv_list=srv_list, os_conn, fip, remote=ssh_controller,
remote=ssh_controller) command='pingv4')

30
plugin_test/tests/test_plugin_vmware_dvs_smoke.py
View File

@ -119,11 +119,10 @@ class TestDVSSmoke(TestBasic):
* Controller * Controller
* Controller * Controller
* Controller * Controller
* Compute * Compute + CephOSD
* CephOSD * Compute + CephOSD
* CephOSD * Compute + CephOSD
* CinderVMware * CinderVMware + ComputeVMware
* ComputeVMware
5. Configure interfaces on nodes. 5. Configure interfaces on nodes.
6. Configure network settings. 6. Configure network settings.
7. Enable and configure DVS plugin. 7. Enable and configure DVS plugin.
@ -163,16 +162,14 @@ class TestDVSSmoke(TestBasic):
{'slave-01': ['controller'], {'slave-01': ['controller'],
'slave-02': ['controller'], 'slave-02': ['controller'],
'slave-03': ['controller'], 'slave-03': ['controller'],
'slave-04': ['compute'], 'slave-04': ['compute', 'ceph-osd'],
'slave-05': ['compute-vmware'], 'slave-05': ['compute', 'ceph-osd'],
'slave-06': ['cinder-vmware'], 'slave-06': ['compute', 'ceph-osd'],
'slave-07': ['ceph-osd'], 'slave-07': ['compute-vmware', 'cinder-vmware']}
'slave-08': ['ceph-osd'],
'slave-09': ['ceph-osd']}
) )
# Configure VMWare vCenter settings # Configure VMWare vCenter settings
target_node_2 = self.node_name('slave-05') target_node_2 = self.node_name('slave-07')
self.fuel_web.vcenter_configure( self.fuel_web.vcenter_configure(
cluster_id, cluster_id,
target_node_2=target_node_2, target_node_2=target_node_2,
@ -180,11 +177,13 @@ class TestDVSSmoke(TestBasic):
) )
self.fuel_web.verify_network(cluster_id, timeout=60 * 15) self.fuel_web.verify_network(cluster_id, timeout=60 * 15)
self.fuel_web.deploy_cluster_wait(cluster_id) self.fuel_web.deploy_cluster_wait(cluster_id, timeout=3600 * 3)
self.fuel_web.run_ostf( self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke']) cluster_id=cluster_id, test_sets=['smoke'])
self.env.make_snapshot("dvs_bvt", is_make=True)
@test(depends_on=[SetupEnvironment.prepare_slaves_1], @test(depends_on=[SetupEnvironment.prepare_slaves_1],
groups=["dvs_install", "dvs_vcenter_plugin"]) groups=["dvs_install", "dvs_vcenter_plugin"])
@log_snapshot_after_test @log_snapshot_after_test
@ -246,6 +245,9 @@ class TestDVSSmoke(TestBasic):
cmd = 'fuel plugins --remove {0}=={1}'.format( cmd = 'fuel plugins --remove {0}=={1}'.format(
plugin.plugin_name, plugin.DVS_PLUGIN_VERSION) plugin.plugin_name, plugin.DVS_PLUGIN_VERSION)
assert_true(self.env.d_env.get_admin_remote().execute(cmd) == 0,
'Can not remove plugin.')
self.show_step(3) self.show_step(3)
cmd = 'fuel plugins list' cmd = 'fuel plugins list'
output = list(self.env.d_env.get_admin_remote().execute( output = list(self.env.d_env.get_admin_remote().execute(
@ -253,5 +255,5 @@ class TestDVSSmoke(TestBasic):
assert_true( assert_true(
plugin.plugin_name not in output, plugin.plugin_name not in output,
"Plugin is removed {}".format(plugin.plugin_name) "Plugin is not removed {}".format(plugin.plugin_name)
) )

539
plugin_test/tests/test_plugin_vmware_dvs_system.py
View File

@ -89,10 +89,12 @@ class TestDVSSystem(TestBasic):
""" """
self.env.revert_snapshot("ready_with_5_slaves") self.env.revert_snapshot("ready_with_5_slaves")
self.show_step(1)
self.show_step(2)
plugin.install_dvs_plugin( plugin.install_dvs_plugin(
self.env.d_env.get_admin_remote()) self.env.d_env.get_admin_remote())
# Configure cluster with 2 vcenter clusters and vcenter glance self.show_step(3)
cluster_id = self.fuel_web.create_cluster( cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__, name=self.__class__.__name__,
mode=DEPLOYMENT_MODE, mode=DEPLOYMENT_MODE,
@ -104,7 +106,9 @@ class TestDVSSystem(TestBasic):
) )
plugin.enable_plugin(cluster_id, self.fuel_web) plugin.enable_plugin(cluster_id, self.fuel_web)
# Assign role to node self.show_step(4)
self.show_step(5)
self.show_step(6)
self.fuel_web.update_nodes( self.fuel_web.update_nodes(
cluster_id, cluster_id,
{'slave-01': ['controller'], {'slave-01': ['controller'],
@ -123,11 +127,14 @@ class TestDVSSystem(TestBasic):
vc_glance=True vc_glance=True
) )
self.show_step(7)
self.fuel_web.deploy_cluster_wait(cluster_id) self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(8)
self.fuel_web.run_ostf( self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke']) cluster_id=cluster_id, test_sets=['smoke'])
self.show_step(9)
self.env.make_snapshot("dvs_vcenter_systest_setup", is_make=True) self.env.make_snapshot("dvs_vcenter_systest_setup", is_make=True)
@test(depends_on=[dvs_vcenter_systest_setup], @test(depends_on=[dvs_vcenter_systest_setup],
@ -147,11 +154,12 @@ class TestDVSSystem(TestBasic):
Duration: 15 min Duration: 15 min
""" """
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup") self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster() cluster_id = self.fuel_web.get_last_created_cluster()
# Create new network self.show_step(2)
os_ip = self.fuel_web.get_public_vip(cluster_id) os_ip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions( os_conn = os_actions.OpenStackActions(
os_ip, SERVTEST_USERNAME, os_ip, SERVTEST_USERNAME,
@ -160,49 +168,52 @@ class TestDVSSystem(TestBasic):
subnets = [] subnets = []
networks = [] networks = []
tenant = os_conn.get_tenant(SERVTEST_TENANT)
for net in self.net_data: for net in self.net_data:
logger.info('Create network {}'.format(net.keys()[0])) logger.info('Create network {}'.format(net.keys()[0]))
network = openstack.create_network( network = os_conn.create_network(
os_conn, network_name=net.keys()[0],
net.keys()[0], tenant_name=SERVTEST_TENANT tenant_id=tenant.id)['network']
)
logger.info('Create subnet {}'.format(net.keys()[0])) logger.info('Create subnet {}'.format(net.keys()[0]))
subnet = openstack.create_subnet( subnet = os_conn.create_subnet(
os_conn, subnet_name=net.keys()[0],
network, network_id=network['id'],
net[net.keys()[0]], tenant_name=SERVTEST_TENANT cidr=net[net.keys()[0]],
) ip_version=4)
subnets.append(subnet) subnets.append(subnet)
networks.append(network) networks.append(network)
# Check that networks are created. self.show_step(3)
for network in networks: for network in networks:
assert_true( assert_true(
os_conn.get_network(network['name'])['id'] == network['id'] os_conn.get_network(network['name'])['id'] == network['id']
) )
# Delete net_1. self.show_step(4)
logger.info('Delete network net_1') logger.info('Delete network net_1')
os_conn.neutron.delete_subnet(subnets[0]['id']) os_conn.neutron.delete_subnet(subnets[0]['id'])
os_conn.neutron.delete_network(networks[0]['id']) os_conn.neutron.delete_network(networks[0]['id'])
# Check that net_1 is deleted.
self.show_step(5)
assert_true( assert_true(
os_conn.get_network(networks[0]) is None os_conn.get_network(networks[0]) is None
) )
logger.info('Networks net_1 is removed.')
logger.info('Created net_1 again.') self.show_step(6)
network = openstack.create_network( network = os_conn.create_network(
os_conn, network_name=self.net_data[0].keys()[0],
self.net_data[0].keys()[0]) tenant_id=tenant.id)['network']
subnet = openstack.create_subnet(
os_conn, logger.info('Create subnet {}'.format(net.keys()[0]))
network, subnet = os_conn.create_subnet(
self.net_data[0][self.net_data[0].keys()[0]], subnet_name=self.net_data[0].keys()[0],
tenant_name=SERVTEST_TENANT network_id=network['id'],
) cidr=self.net_data[0][self.net_data[0].keys()[0]],
ip_version=4)
assert_true( assert_true(
os_conn.get_network(network['name'])['id'] == network['id'] os_conn.get_network(network['name'])['id'] == network['id']
) )
@ -230,71 +241,64 @@ class TestDVSSystem(TestBasic):
Duration: 15 min Duration: 15 min
""" """
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup") self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster() cluster_id = self.fuel_web.get_last_created_cluster()
# Create new network
os_ip = self.fuel_web.get_public_vip(cluster_id) os_ip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions( os_conn = os_actions.OpenStackActions(
os_ip, SERVTEST_USERNAME, os_ip, SERVTEST_USERNAME,
SERVTEST_PASSWORD, SERVTEST_PASSWORD,
SERVTEST_TENANT) SERVTEST_TENANT)
# Create non default network with subnet. tenant = os_conn.get_tenant(SERVTEST_TENANT)
logger.info('Create network {}'.format(self.net_data[0].keys()[0]))
network = openstack.create_network(
os_conn,
self.net_data[0].keys()[0], tenant_name=SERVTEST_TENANT
)
logger.info('Create subnet {}'.format(self.net_data[0].keys()[0])) self.show_step(2)
subnet = openstack.create_subnet( network = os_conn.create_network(
os_conn, network_name=self.net_data[0].keys()[0],
network, tenant_id=tenant.id)['network']
self.net_data[0][self.net_data[0].keys()[0]],
tenant_name=SERVTEST_TENANT self.show_step(3)
) subnet = os_conn.create_subnet(
subnet_name=network['name'],
network_id=network['id'],
cidr=self.net_data[0][self.net_data[0].keys()[0]],
ip_version=4)
# Check that network are created. # Check that network are created.
assert_true( assert_true(
os_conn.get_network(network['name'])['id'] == network['id'] os_conn.get_network(network['name'])['id'] == network['id']
) )
self.show_step(4)
router = os_conn.get_router(os_conn.get_network(self.ext_net_name))
os_conn.add_router_interface(
router_id=router["id"],
subnet_id=subnet["id"])
# create security group with rules for ssh and ping # create security group with rules for ssh and ping
security_group = os_conn.create_sec_group_for_ssh() security_group = os_conn.create_sec_group_for_ssh()
# Launch instance VM_1, VM_2 in the tenant network net_01 self.show_step(5)
# with image TestVMDK and flavor m1.micro in the nova az. self.show_step(6)
# Launch instances VM_3 and VM_4 in the net01 instances = openstack.create_instances(
# with image TestVM-VMDK and flavor m1.micro in vcenter az.
openstack.create_instances(
os_conn=os_conn, nics=[{'net-id': network['id']}], vm_count=1, os_conn=os_conn, nics=[{'net-id': network['id']}], vm_count=1,
security_groups=[security_group.name] security_groups=[security_group.name]
) )
openstack.verify_instance_state(os_conn) openstack.verify_instance_state(os_conn)
# Add net_1 to default router # Get floating ip of instances.
router = os_conn.get_router(os_conn.get_network(self.ext_net_name)) fip = openstack.create_and_assign_floating_ips(os_conn, instances)
openstack.add_subnet_to_router(
os_conn,
router['id'], subnet['id'])
openstack.create_and_assign_floating_ip(os_conn=os_conn) self.show_step(7)
controller = self.fuel_web.get_nailgun_primary_node(
# Send ping from instances VM_1 and VM_2 to 8.8.8.8
# or other outside ip.
srv_list = os_conn.get_servers()
primary_controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0] self.env.d_env.nodes().slaves[0]
) )
ssh_controller = self.fuel_web.get_ssh_for_node( with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
primary_controller.name) openstack.check_connection_vms(
openstack.check_connection_vms( os_conn, fip, remote=ssh_contr,
os_conn=os_conn, srv_list=srv_list, command='pingv4', command='pingv4', destination_ip=['8.8.8.8'])
remote=ssh_controller,
destination_ip=['8.8.8.8']
)
@test(depends_on=[dvs_vcenter_systest_setup], @test(depends_on=[dvs_vcenter_systest_setup],
groups=["dvs_instances_one_group", 'dvs_vcenter_system']) groups=["dvs_instances_one_group", 'dvs_vcenter_system'])
@ -316,6 +320,7 @@ class TestDVSSystem(TestBasic):
Duration: 15 min Duration: 15 min
""" """
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup") self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster() cluster_id = self.fuel_web.get_last_created_cluster()
@ -335,51 +340,42 @@ class TestDVSSystem(TestBasic):
security_group = os_conn.create_sec_group_for_ssh() security_group = os_conn.create_sec_group_for_ssh()
# Get max count of instance which we can create according to resource # Get max count of instance which we can create according to resource
# limitdos.py revert-resume dvs_570 error_dvs_instances_batch # limit
vm_count = min( vm_count = min(
[os_conn.nova.hypervisors.resource_class.to_dict(h)['vcpus'] [os_conn.nova.hypervisors.resource_class.to_dict(h)['vcpus']
for h in os_conn.nova.hypervisors.list()] for h in os_conn.nova.hypervisors.list()]
) )
logger.info(security_group) self.show_step(2)
self.show_step(3)
openstack.create_instances( openstack.create_instances(
os_conn=os_conn, nics=[{'net-id': network.id}], os_conn=os_conn, nics=[{'net-id': network.id}],
vm_count=vm_count, security_groups=[security_group.name] vm_count=vm_count, security_groups=[security_group.name]
) )
openstack.verify_instance_state(os_conn) openstack.verify_instance_state(os_conn)
logger.info("Check ping is available between instances.") self.show_step(4)
openstack.create_and_assign_floating_ip(os_conn=os_conn)
srv_list = os_conn.nova.servers.list() srv_list = os_conn.nova.servers.list()
fip = openstack.create_and_assign_floating_ips(os_conn, srv_list)
primary_controller = self.fuel_web.get_nailgun_primary_node( controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0]) self.env.d_env.nodes().slaves[0])
ssh_controller = self.fuel_web.get_ssh_for_node( with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
primary_controller.name) openstack.check_connection_vms(
os_conn, fip, remote=ssh_contr,
command='pingv4')
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list,
command='pingv4', remote=ssh_controller)
logger.info("Check ssh connection is available between instances.")
floating_ip = []
for srv in srv_list:
floating_ip.append(
[add['addr']
for add in srv.addresses[srv.addresses.keys()[0]]
if add['OS-EXT-IPS:type'] == 'floating'][0])
ip_pair = [ ip_pair = [
(ip_1, ip_2) (ip_1, ip_2)
for ip_1 in floating_ip for ip_1 in fip
for ip_2 in floating_ip for ip_2 in fip
if ip_1 != ip_2] if ip_1 != ip_2]
for ips in ip_pair: for ips in ip_pair:
openstack.check_ssh_between_instances(ips[0], ips[1]) openstack.remote_execute_command(ips[0], ips[1], ' ')
logger.info("Delete all instances from horizon simultaneously.") self.show_step(5)
for srv in srv_list: for srv in srv_list:
os_conn.nova.servers.delete(srv) os_conn.nova.servers.delete(srv)
@ -445,6 +441,7 @@ class TestDVSSystem(TestBasic):
"protocol": "icmp", "protocol": "icmp",
"security_group_id": ""}} "security_group_id": ""}}
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup") self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster() cluster_id = self.fuel_web.get_last_created_cluster()
@ -457,8 +454,7 @@ class TestDVSSystem(TestBasic):
tenant = os_conn.get_tenant(SERVTEST_TENANT) tenant = os_conn.get_tenant(SERVTEST_TENANT)
logger.info("Create non default network with subnet.") self.show_step(2)
logger.info('Create network {}'.format(self.net_data[0].keys()[0]))
network = os_conn.create_network( network = os_conn.create_network(
network_name=self.net_data[0].keys()[0], network_name=self.net_data[0].keys()[0],
tenant_id=tenant.id)['network'] tenant_id=tenant.id)['network']
@ -480,8 +476,7 @@ class TestDVSSystem(TestBasic):
router_id=router["id"], router_id=router["id"],
subnet_id=subnet["id"]) subnet_id=subnet["id"])
logger.info("""Launch 2 instances of vcenter and 2 instances of nova self.show_step(3)
in the tenant network net_01.""")
openstack.create_instances( openstack.create_instances(
os_conn=os_conn, os_conn=os_conn,
nics=[{'net-id': network['id']}], nics=[{'net-id': network['id']}],
@ -489,9 +484,7 @@ class TestDVSSystem(TestBasic):
) )
openstack.verify_instance_state(os_conn) openstack.verify_instance_state(os_conn)
logger.info("""Launch 2 instances of vcenter and self.show_step(4)
2 instances of nova
in the default tenant network.""")
network = os_conn.nova.networks.find(label=self.inter_net_name) network = os_conn.nova.networks.find(label=self.inter_net_name)
openstack.create_instances( openstack.create_instances(
os_conn=os_conn, os_conn=os_conn,
@ -501,25 +494,18 @@ class TestDVSSystem(TestBasic):
openstack.verify_instance_state(os_conn) openstack.verify_instance_state(os_conn)
srv_list = os_conn.get_servers() srv_list = os_conn.get_servers()
floating_ip = [] self.show_step(5)
for srv in srv_list:
floating_ip.append(
os_conn.assign_floating_ip(
srv, use_neutron=True)['floating_ip_address'])
logger.info("""Create security groups SG_1 to allow ICMP traffic.
Add Ingress rule for ICMP protocol to SG_1
Create security groups SG_2 to allow TCP traffic 22 port.
Add Ingress rule for TCP protocol to SG_2.""")
sec_name = ['SG1', 'SG2'] sec_name = ['SG1', 'SG2']
sg1 = os_conn.nova.security_groups.create( sg1 = os_conn.nova.security_groups.create(
sec_name[0], "descr") sec_name[0], "descr")
sg2 = os_conn.nova.security_groups.create( self.show_step(6)
sec_name[1], "descr")
tcp["security_group_rule"]["security_group_id"] = sg1.id tcp["security_group_rule"]["security_group_id"] = sg1.id
os_conn.neutron.create_security_group_rule(tcp) os_conn.neutron.create_security_group_rule(tcp)
self.show_step(7)
sg2 = os_conn.nova.security_groups.create(
sec_name[1], "descr")
self.show_step(8)
icmp["security_group_rule"]["security_group_id"] = sg2.id icmp["security_group_rule"]["security_group_id"] = sg2.id
os_conn.neutron.create_security_group_rule(icmp) os_conn.neutron.create_security_group_rule(icmp)
@ -531,29 +517,28 @@ class TestDVSSystem(TestBasic):
srv.add_security_group(sg1.id) srv.add_security_group(sg1.id)
srv.add_security_group(sg2.id) srv.add_security_group(sg2.id)
time.sleep(20) # need wait to update rules on dvs floating_ip = openstack.create_and_assign_floating_ips(
os_conn, srv_list)
logger.info("Check ping between instances.") self.show_step(9)
primary_controller = self.fuel_web.get_nailgun_primary_node( controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0] self.env.d_env.nodes().slaves[0])
)
ssh_controller = self.fuel_web.get_ssh_for_node(
primary_controller.name)
logger.info("Check ping is available between instances.") with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list, openstack.check_connection_vms(
command='pingv4', remote=ssh_controller) os_conn, floating_ip, remote=ssh_contr,
command='pingv4')
logger.info("Check ssh connection is available between instances.") self.show_step(10)
ip_pair = [(ip_1, ip_2) ip_pair = [(ip_1, ip_2)
for ip_1 in floating_ip for ip_1 in floating_ip
for ip_2 in floating_ip for ip_2 in floating_ip
if ip_1 != ip_2] if ip_1 != ip_2]
for ips in ip_pair: for ips in ip_pair:
openstack.check_ssh_between_instances(ips[0], ips[1]) openstack.remote_execute_command(ips[0], ips[1], ' ')
logger.info("Delete all rules from SG_1 and SG_2") self.show_step(11)
sg_rules = os_conn.neutron.list_security_group_rules()[ sg_rules = os_conn.neutron.list_security_group_rules()[
'security_group_rules'] 'security_group_rules']
sg_rules = [ sg_rules = [
@ -566,7 +551,7 @@ class TestDVSSystem(TestBasic):
time.sleep(20) # need wait to update rules on dvs time.sleep(20) # need wait to update rules on dvs
logger.info("Check ssh are not available to instances") self.show_step(12)
for ip in floating_ip: for ip in floating_ip:
try: try:
openstack.get_ssh_connection( openstack.get_ssh_connection(
@ -575,7 +560,7 @@ class TestDVSSystem(TestBasic):
except Exception as e: except Exception as e:
logger.info('{}'.format(e)) logger.info('{}'.format(e))
logger.info("Add Ingress and egress rules for TCP protocol to SG_2") self.show_step(13)
tcp["security_group_rule"]["security_group_id"] = sg2.id tcp["security_group_rule"]["security_group_id"] = sg2.id
os_conn.neutron.create_security_group_rule(tcp) os_conn.neutron.create_security_group_rule(tcp)
tcp["security_group_rule"]["direction"] = "egress" tcp["security_group_rule"]["direction"] = "egress"
@ -583,15 +568,17 @@ class TestDVSSystem(TestBasic):
time.sleep(20) # need wait to update rules on dvs ports time.sleep(20) # need wait to update rules on dvs ports
logger.info("Check ssh connection is available between instances.") self.show_step(14)
for ips in ip_pair: for ips in ip_pair:
openstack.check_ssh_between_instances(ips[0], ips[1]) openstack.remote_execute_command(ips[0], ips[1], ' ')
logger.info("Check ping is not available between instances.") self.show_step(15)
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list, with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
command='pingv4', remote=ssh_controller, openstack.check_connection_vms(
result_of_command=1) os_conn, floating_ip, remote=ssh_contr,
command='pingv4', result_of_command=1)
self.show_step(16)
logger.info("Add Ingress and egress rules for ICMP protocol to SG_1") logger.info("Add Ingress and egress rules for ICMP protocol to SG_1")
icmp["security_group_rule"]["security_group_id"] = sg1.id icmp["security_group_rule"]["security_group_id"] = sg1.id
os_conn.neutron.create_security_group_rule(icmp) os_conn.neutron.create_security_group_rule(icmp)
@ -600,12 +587,14 @@ class TestDVSSystem(TestBasic):
time.sleep(20) # need wait to update rules on dvs ports time.sleep(20) # need wait to update rules on dvs ports
logger.info("Check ping is available between instances.") self.show_step(17)
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list, with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
command='pingv4', remote=ssh_controller) openstack.check_connection_vms(
os_conn, floating_ip, remote=ssh_contr,
command='pingv4')
logger.info("""Delete SG1 and SG2 security groups. self.show_step(21)
Attach instances to default security group.""") self.show_step(22)
srv_list = os_conn.get_servers() srv_list = os_conn.get_servers()
for srv in srv_list: for srv in srv_list:
for sg in srv.security_groups: for sg in srv.security_groups:
@ -623,13 +612,15 @@ class TestDVSSystem(TestBasic):
os_conn.neutron.create_security_group_rule(tcp) os_conn.neutron.create_security_group_rule(tcp)
time.sleep(20) # need wait to update rules on dvs ports time.sleep(20) # need wait to update rules on dvs ports
logger.info("Check ping is available between instances.") self.show_step(23)
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list, with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
command='pingv4', remote=ssh_controller) openstack.check_connection_vms(
os_conn, floating_ip, remote=ssh_contr,
command='pingv4')
logger.info("Check ssh connection is available between instances.") self.show_step(24)
for ips in ip_pair: for ips in ip_pair:
openstack.check_ssh_between_instances(ips[0], ips[1]) openstack.remote_execute_command(ips[0], ips[1], ' ')
@test(depends_on=[dvs_vcenter_systest_setup], @test(depends_on=[dvs_vcenter_systest_setup],
groups=["dvs_vcenter_tenants_isolation", 'dvs_vcenter_system']) groups=["dvs_vcenter_tenants_isolation", 'dvs_vcenter_system'])
@ -655,103 +646,87 @@ class TestDVSSystem(TestBasic):
Duration: 30 min Duration: 30 min
""" """
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup") self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster() cluster_id = self.fuel_web.get_last_created_cluster()
# Create new network
os_ip = self.fuel_web.get_public_vip(cluster_id) os_ip = self.fuel_web.get_public_vip(cluster_id)
admin = os_actions.OpenStackActions( admin = os_actions.OpenStackActions(
os_ip, SERVTEST_USERNAME, os_ip, SERVTEST_USERNAME,
SERVTEST_PASSWORD, SERVTEST_PASSWORD,
SERVTEST_TENANT) SERVTEST_TENANT)
# Create non-admin tenant. self.show_step(2)
admin.create_user_and_tenant('test', 'test', 'test') admin.create_user_and_tenant('test', 'test', 'test')
openstack.add_role_to_user(admin, 'test', 'admin', 'test') openstack.add_role_to_user(admin, 'test', 'admin', 'test')
test = os_actions.OpenStackActions( test = os_actions.OpenStackActions(
os_ip, 'test', 'test', 'test') os_ip, 'test', 'test', 'test')
# Create non default network with subnet in test tenant. tenant = test.get_tenant('test')
logger.info('Create network {}'.format(self.net_data[0].keys()[0]))
network = openstack.create_network(
test,
self.net_data[0].keys()[0], tenant_name='test'
)
logger.info('Create subnet {}'.format(self.net_data[0].keys()[0])) self.show_step(3)
subnet = openstack.create_subnet( network_test = test.create_network(
test, network_name=self.net_data[0].keys()[0],
network, tenant_id=tenant.id)['network']
self.net_data[0][self.net_data[0].keys()[0]],
tenant_name='test' subnet_test = test.create_subnet(
) subnet_name=network_test['name'],
network_id=network_test['id'],
cidr=self.net_data[0][self.net_data[0].keys()[0]],
ip_version=4)
# create security group with rules for ssh and ping # create security group with rules for ssh and ping
security_group = test.create_sec_group_for_ssh() security_group_test = test.create_sec_group_for_ssh()
# Launch 2 instances in the est tenant network net_01 self.show_step(4)
openstack.create_instances( router = test.create_router('router_1', tenant=tenant)
os_conn=test, vm_count=1, test.add_router_interface(
nics=[{'net-id': network['id']}], router_id=router["id"],
security_groups=[security_group.name] subnet_id=subnet_test["id"])
)
openstack.verify_instance_state(test)
# Create Router_01, set gateway and add interface
# to external network.
router_1 = openstack.add_router(
test,
'router_1'
)
# Add net_1 to router_1
openstack.add_subnet_to_router(
test,
router_1['id'], subnet['id'])
# create security group with rules for ssh and ping # create security group with rules for ssh and ping
security_group = admin.create_sec_group_for_ssh() security_group = admin.create_sec_group_for_ssh()
# Launch 2 instances in the admin tenant net04 self.show_step(5)
network = admin.nova.networks.find(label=self.inter_net_name) network = admin.nova.networks.find(label=self.inter_net_name)
openstack.create_instances( srv_1 = openstack.create_instances(
os_conn=admin, nics=[{'net-id': network.id}], vm_count=1, os_conn=admin, nics=[{'net-id': network.id}], vm_count=1,
security_groups=[security_group.name]) security_groups=[security_group.name])
openstack.verify_instance_state(admin) openstack.verify_instance_state(admin)
# Send ping from instances VM_1 and VM_2 to VM_3 and VM_4 self.show_step(6)
# via no floating ip srv_2 = openstack.create_instances(
srv_1 = admin.get_servers() os_conn=test, vm_count=1,
srv_2 = test.get_servers() nics=[{'net-id': network_test['id']}],
openstack.create_and_assign_floating_ip(os_conn=admin, srv_list=srv_1) security_groups=[security_group_test.name]
openstack.create_and_assign_floating_ip( )
os_conn=test, openstack.verify_instance_state(test)
srv_list=srv_2,
ext_net=None,
tenant_id=test.get_tenant('test').id)
srv_1 = admin.get_servers() self.show_step(7)
srv_2 = test.get_servers() fip_1 = openstack.create_and_assign_floating_ips(admin, srv_1)
ips_1 = []
for srv in srv_1:
ips_1.append(admin.get_nova_instance_ip(
srv, net_name=self.inter_net_name))
ips = [] fip_2 = openstack.create_and_assign_floating_ips(test, srv_2)
ips_2 = []
for srv in srv_2: for srv in srv_2:
ip = srv.networks[srv.networks.keys()[0]][0] ips_2.append(test.get_nova_instance_ip(
ips.append(ip) srv, net_name=network_test['name']))
logger.info(ips) controller = self.fuel_web.get_nailgun_primary_node(
logger.info(srv_1)
primary_controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0] self.env.d_env.nodes().slaves[0]
) )
ssh_controller = self.fuel_web.get_ssh_for_node( with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
primary_controller.name) openstack.check_connection_vms(
openstack.check_connection_vms( admin, fip_1, remote=ssh_contr,
os_conn=admin, srv_list=srv_1, command='pingv4', command='pingv4', destination_ip=ips_2, result_of_command=1)
result_of_command=1, openstack.check_connection_vms(
remote=ssh_controller, destination_ip=ips admin, fip_2, remote=ssh_contr,
) command='pingv4', destination_ip=ips_1, result_of_command=1)
@test(depends_on=[dvs_vcenter_systest_setup], @test(depends_on=[dvs_vcenter_systest_setup],
groups=["dvs_vcenter_same_ip", 'dvs_vcenter_system']) groups=["dvs_vcenter_same_ip", 'dvs_vcenter_system'])
@ -765,14 +740,14 @@ class TestDVSSystem(TestBasic):
3. Create private network net01 with subnet in non-admin tenant. 3. Create private network net01 with subnet in non-admin tenant.
4. Create Router_01, set gateway and add interface 4. Create Router_01, set gateway and add interface
to external network. to external network.
5. Create private network net01 with subnet in default admin tenant 5. Launch instances VM_1 and VM_2
6. Create Router_01, set gateway and add interface
to external network.
7. Launch instances VM_1 and VM_2
in the net01(non-admin tenant) in the net01(non-admin tenant)
with image TestVM and flavor m1.micro in nova az. with image TestVM and flavor m1.micro in nova az.
8. Launch instances VM_3 and VM_4 in the net01(non-admin tenant) 6. Launch instances VM_3 and VM_4 in the net01(non-admin tenant)
with image TestVM-VMDK and flavor m1.micro in vcenter az. with image TestVM-VMDK and flavor m1.micro in vcenter az.
7. Create private network net01 with subnet in default admin tenant
8. Create Router_01, set gateway and add interface
to external network.
9. Launch instances VM_5 and VM_6 9. Launch instances VM_5 and VM_6
in the net01(default admin tenant) in the net01(default admin tenant)
with image TestVM and flavor m1.micro in nova az. with image TestVM and flavor m1.micro in nova az.
@ -787,6 +762,7 @@ class TestDVSSystem(TestBasic):
Duration: 30 min Duration: 30 min
""" """
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup") self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster() cluster_id = self.fuel_web.get_last_created_cluster()
@ -797,119 +773,99 @@ class TestDVSSystem(TestBasic):
SERVTEST_PASSWORD, SERVTEST_PASSWORD,
SERVTEST_TENANT) SERVTEST_TENANT)
# Create non-admin tenant. tenant_admin = admin.get_tenant(SERVTEST_TENANT)
self.show_step(2)
admin.create_user_and_tenant('test', 'test', 'test') admin.create_user_and_tenant('test', 'test', 'test')
openstack.add_role_to_user(admin, 'test', 'admin', 'test') openstack.add_role_to_user(admin, 'test', 'admin', 'test')
test = os_actions.OpenStackActions( test = os_actions.OpenStackActions(
os_ip, 'test', 'test', 'test') os_ip, 'test', 'test', 'test')
# Create non default network with subnet in test tenant. tenant = test.get_tenant('test')
logger.info('Create network {}'.format(self.net_data[0].keys()[0]))
network = openstack.create_network(
test,
self.net_data[0].keys()[0], tenant_name='test'
)
logger.info('Create subnet {}'.format(self.net_data[0].keys()[0])) self.show_step(3)
subnet = openstack.create_subnet( logger.info('Create network {}'.format(self.net_data[0].keys()[0]))
test, network = test.create_network(
network, network_name=self.net_data[0].keys()[0],
self.net_data[0][self.net_data[0].keys()[0]], tenant_id=tenant.id)['network']
tenant_name='test'
) subnet = test.create_subnet(
subnet_name=network['name'],
network_id=network['id'],
cidr=self.net_data[0][self.net_data[0].keys()[0]],
ip_version=4)
self.show_step(4)
router = test.create_router('router_1', tenant=tenant)
test.add_router_interface(
router_id=router["id"],
subnet_id=subnet["id"])
# create security group with rules for ssh and ping # create security group with rules for ssh and ping
security_group = test.create_sec_group_for_ssh() security_group = test.create_sec_group_for_ssh()
# Launch instances VM_1 and VM_2 in the net01(non-admin tenant) self.show_step(5)
# with image TestVM and flavor m1.micro in nova az. self.show_step(6)
# Launch instances VM_3 and VM_4 in the net01(non-admin tenant) srv_1 = openstack.create_instances(
# with image TestVM-VMDK and flavor m1.micro in vcenter az.
openstack.create_instances(
os_conn=test, nics=[{'net-id': network['id']}], vm_count=1, os_conn=test, nics=[{'net-id': network['id']}], vm_count=1,
security_groups=[security_group.name] security_groups=[security_group.name]
) )
openstack.verify_instance_state(test) openstack.verify_instance_state(test)
# Create Router_01, set gateway and add interface fip_1 = openstack.create_and_assign_floating_ips(test, srv_1)
# to external network. ips_1 = []
router_1 = openstack.add_router( for srv in srv_1:
test, ips_1.append(test.get_nova_instance_ip(
'router_1', srv, net_name=network['name']))
ext_net_name=self.ext_net_name, tenant_name='test'
)
# Add net_1 to router_1
openstack.add_subnet_to_router(
test,
router_1['id'], subnet['id'])
srv_1 = test.get_servers()
openstack.create_and_assign_floating_ip(
os_conn=test,
srv_list=srv_1,
ext_net=None,
tenant_id=test.get_tenant('test').id)
srv_1 = test.get_servers()
# create security group with rules for ssh and ping # create security group with rules for ssh and ping
security_group = admin.create_sec_group_for_ssh() security_group = admin.create_sec_group_for_ssh()
# Create non default network with subnet in admin tenant.
self.show_step(7)
logger.info('Create network {}'.format(self.net_data[0].keys()[0])) logger.info('Create network {}'.format(self.net_data[0].keys()[0]))
network = openstack.create_network( network = admin.create_network(
admin, network_name=self.net_data[0].keys()[0],
self.net_data[0].keys()[0]) tenant_id=tenant_admin.id)['network']
logger.info('Create subnet {}'.format(self.net_data[0].keys()[0])) subnet = admin.create_subnet(
subnet = openstack.create_subnet( subnet_name=network['name'],
admin, network_id=network['id'],
network, cidr=self.net_data[0][self.net_data[0].keys()[0]],
self.net_data[0][self.net_data[0].keys()[0]]) ip_version=4)
# Launch instances VM_5 and VM_6 self.show_step(8)
# in the net01(default admin tenant) router = admin.create_router('router_1', tenant=tenant)
# with image TestVM and flavor m1.micro in nova az. admin.add_router_interface(
# Launch instances VM_7 and VM_8 router_id=router["id"],
# in the net01(default admin tenant) subnet_id=subnet["id"])
# with image TestVM-VMDK and flavor m1.micro in vcenter az.
openstack.create_instances( self.show_step(9)
self.show_step(10)
srv_2 = openstack.create_instances(
os_conn=admin, nics=[{'net-id': network['id']}], vm_count=1, os_conn=admin, nics=[{'net-id': network['id']}], vm_count=1,
security_groups=[security_group.name]) security_groups=[security_group.name])
openstack.verify_instance_state(admin) openstack.verify_instance_state(admin)
# Create Router_01, set gateway and add interface self.show_step(11)
# to external network. self.show_step(12)
router_1 = openstack.add_router( fip_2 = openstack.create_and_assign_floating_ips(admin, srv_2)
admin, ips_2 = []
'router_1') for srv in srv_2:
ips_2.append(admin.get_nova_instance_ip(
srv, net_name=network['name']))
# Add net_1 to router_1 controller = self.fuel_web.get_nailgun_primary_node(
openstack.add_subnet_to_router(
admin,
router_1['id'], subnet['id'])
# Send ping between instances
# via no floating ip
srv_2 = admin.get_servers()
openstack.create_and_assign_floating_ip(
os_conn=admin,
srv_list=srv_2)
srv_2 = admin.get_servers()
# Verify that VM_1, VM_2, VM_3 and VM_4 should communicate
# between each other via fixed ip.
primary_controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0] self.env.d_env.nodes().slaves[0]
) )
ssh_controller = self.fuel_web.get_ssh_for_node(
primary_controller.name)
openstack.check_connection_vms(
os_conn=test, srv_list=srv_1, remote=ssh_controller)
# Verify that VM_5, VM_6, VM_7 and VM_8 should communicate with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
# between each other via fixed ip. openstack.check_connection_vms(
openstack.check_connection_vms(os_conn=admin, srv_list=srv_2, test, fip_1, remote=ssh_contr,
remote=ssh_controller) command='pingv4', destination_ip=ips_1)
openstack.check_connection_vms(
admin, fip_2, remote=ssh_contr,
command='pingv4', destination_ip=ips_2)
@test(depends_on=[SetupEnvironment.prepare_slaves_5], @test(depends_on=[SetupEnvironment.prepare_slaves_5],
groups=["dvs_volume", 'dvs_vcenter_system']) groups=["dvs_volume", 'dvs_vcenter_system'])
@ -1471,10 +1427,9 @@ class TestDVSSystem(TestBasic):
map_router_subnet[1]['router'], map_router_subnet[1]['router'],
{"subnet_id": map_router_subnet[1]['subnet']}) {"subnet_id": map_router_subnet[1]['subnet']})
openstack.add_subnet_to_router( admin.add_router_interface(
admin, router_id=map_router_subnet[0]['router'],
map_router_subnet[0]['router'], subnet_id=map_router_subnet[1]['subnet'])
map_router_subnet[1]['subnet'])
time.sleep(20) # need wait to port state update time.sleep(20) # need wait to port state update
self.show_step(14) self.show_step(14)
for ip in instances_group[1]['private_ips']: for ip in instances_group[1]['private_ips']: