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
* Compute + CephOSD
* Compute + CephOSD
* Compute + CephOSD
* CinderVMware + ComputeVMware
4. Configure interfaces on nodes.
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.helpers.helpers import icmp_ping
from devops.helpers.helpers import wait
from fuelweb_test import logger
from fuelweb_test.settings import SERVTEST_TENANT
import paramiko
from proboscis.asserts import assert_true
import yaml
# timeouts
BOOT_TIMEOUT = 300
def get_defaults():
"""Get default parameters from config.yaml."""
with open('plugin_test/helpers/config.yaml') as config:
defaults = yaml.load(config.read())
logger.info(''.format(defaults))
@ -43,7 +46,7 @@ instance_creds = (
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.
: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 boot_timeout: type int, time in seconds to build instance
"""
boot_timeout = 300
if not instances:
instances = os_conn.nova.servers.list()
for instance in instances:
@ -59,7 +61,7 @@ def verify_instance_state(os_conn, instances=None, expected_state='ACTIVE',
wait(
lambda:
os_conn.get_instance_detail(instance).status == expected_state,
timeout=boot_timeout)
timeout=BOOT_TIMEOUT)
except TimeoutError:
current_state = os_conn.get_instance_detail(instance).status
assert_true(
@ -102,57 +104,76 @@ def create_instances(os_conn, nics, vm_count=1,
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,
destination_ip=None):
"""Check network connectivity between instances.
:param os_conn: type object, openstack
:param srv_list: type list, instances
:param packets: type int, packets count of icmp reply
:param fip: type list, floating ips of instances
:param remote: SSHClient to primary controller
: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 = {
"pingv4": "ping -c 5 {}",
"pingv6": "ping6 -c 5 {}",
"arping": "sudo arping -I eth0 {}"}
for srv in srv_list:
addresses = srv.addresses[srv.addresses.keys()[0]]
fip = [
add['addr']
for add in addresses
if add['OS-EXT-IPS:type'] == 'floating'][0]
if not destination_ip:
ip_pair = [
(ip_1, ip_2)
for ip_1 in fip
for ip_2 in fip
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:
destination_ip = [s.networks[s.networks.keys()[0]][0]
for s in srv_list if s != srv]
assert_true(
result_of_command == command_result['exit_code'],
" 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]:
logger.info("Connect to VM {0}".format(fip))
command_result = os_conn.execute_through_host(
remote, fip,
commands[command].format(ip), instance_creds)
logger.info("Command result: \n"
"{0}\n"
"{1}\n"
"exit_code={2}"
.format(command_result['stdout'],
command_result['stderr'],
command_result['exit_code']))
assert_true(
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 create_and_assign_floating_ips(os_conn, instances_list):
"""Create Vms on available hypervisors.
:param os_conn: type object, openstack
:param instances_list: type list, instances
"""
fips = []
for instance in instances_list:
ip = os_conn.assign_floating_ip(
instance).ip
fips.append(ip)
wait(lambda: icmp_ping(ip), timeout=60 * 3, interval=5)
return fips
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.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(
@ -162,34 +183,6 @@ def get_ssh_connection(ip, username, userpassword, timeout=30, port=22):
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):
"""Check execute remote command.
@ -236,92 +229,8 @@ def remote_execute_command(instance1_ip, instance2_ip, command):
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):
"""Get role by name."""
role_list = os_conn.keystone.roles.list()
for role in role_list:
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):
"""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
user_id = os_conn.get_user(user_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 size: type int, size of volume
"""
boot_timeout = 300
images_list = os_conn.nova.images.list()
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)
wait(
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}'"
.format(volume.id, image.id))
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 TestBasic
from tests.test_plugin_vmware_dvs_system import TestDVSSystem
from helpers import openstack
from helpers import plugin
@ -54,84 +55,30 @@ class TestDVSDestructive(TestBasic):
"""Get node by name."""
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
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],
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],
@test(depends_on=[TestDVSSystem.dvs_vcenter_systest_setup],
groups=["dvs_vcenter_uninstall", 'dvs_vcenter_system'])
@log_snapshot_after_test
def dvs_vcenter_uninstall(self):
"""Negative uninstall of Fuel DVS plugin with deployed environment.
Scenario:
1. Revert snapshot to dvs_vcenter_destructive_setup.
1. Revert snapshot to dvs_vcenter_systest_setup.
2. Try to uninstall dvs plugin.
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
cmd = 'fuel plugins --remove {0}=={1}'.format(
@ -148,8 +95,8 @@ class TestDVSDestructive(TestBasic):
"Plugin is removed {}".format(plugin.plugin_name)
)
@test(depends_on=[dvs_vcenter_destructive_setup],
groups=["dvs_vcenter_bind_port", "dvs_vcenter_destructive_setup"])
@test(depends_on=[TestDVSSystem.dvs_vcenter_systest_setup],
groups=["dvs_vcenter_bind_port"])
@log_snapshot_after_test
def dvs_vcenter_bind_port(self):
"""Check abilities to bind port on DVS to VM, disable/enable this port.
@ -171,7 +118,7 @@ class TestDVSDestructive(TestBasic):
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()
@ -185,74 +132,86 @@ class TestDVSDestructive(TestBasic):
# create security group with rules for ssh and ping
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
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,
instances = 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)
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']
srv_list = os_conn.get_servers()
for srv in srv_list:
srv_addr = srv.networks[srv.networks.keys()[0]][0]
floating_ip = openstack.create_and_assign_floating_ips(
os_conn, instances)
instance_ports = []
for instance in instances:
instance_addr = os_conn.get_nova_instance_ip(
instance, net_name=network['name'])
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': False}}
)
if instance_addr == port_addr:
instance_ports.append(port)
for port in instance_ports:
os_conn.neutron.update_port(
port['id'], {'port': {'admin_state_up': False}}
)
srv_list = os_conn.get_servers()
# Verify that not connection to instances
primary_controller = self.fuel_web.get_nailgun_primary_node(
controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0]
)
ssh_controller = self.fuel_web.get_ssh_for_node(
primary_controller.name
)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_controller:
# 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(
os_conn=os_conn, srv_list=srv_list, remote=ssh_controller)
except Exception as e:
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)
os_conn, floating_ip, remote=ssh_controller,
command='pingv4')
@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
def dvs_vcenter_reset_controller(self):
def dvs_destructive_setup_2(self):
"""Verify that vmclusters should be migrate after reset controller.
Scenario:
@ -263,12 +222,6 @@ class TestDVSDestructive(TestBasic):
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
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
@ -316,156 +269,130 @@ class TestDVSDestructive(TestBasic):
security_group = os_conn.create_sec_group_for_ssh()
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,
security_groups=[security_group.name]
)
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.
# Send ping Check that ping get reply.
openstack.create_and_assign_floating_ip(os_conn=os_conn)
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]
)
ssh_controller = self.fuel_web.get_ssh_for_node(
primary_controller.name
)
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list,
remote=ssh_controller)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_control:
openstack.check_service(ssh=ssh_control, commands=self.cmds)
openstack.check_connection_vms(
os_conn, floating_ip, remote=ssh_control,
command='pingv4')
cmds = ['nova-manage service list | grep vcenter-vmcluster1',
'nova-manage service list | grep vcenter-vmcluster2']
self.fuel_web.cold_restart_nodes(
[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)
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(
controller = self.fuel_web.get_nailgun_primary_node(
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.
# Send ping Check that ping get reply.
srv_list = os_conn.get_servers()
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list,
remote=ssh_controller)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_control:
openstack.check_service(ssh=ssh_control, commands=self.cmds)
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'])
@log_snapshot_after_test
def dvs_vcenter_shutdown_controller(self):
"""Verify that vmclusters should be migrate after shutdown controller.
Scenario:
1. Upload plugins to the master node
2. Install plugin.
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,
1. Revert to 'dvs_destructive_setup_2' snapshot.
2. Verify connection between instances. Send ping,
check that ping get reply.
9. Shutdown controller.
10. Check that vmclusters should be migrate to another controller.
11. Verify connection between instances.
3. Shutdown 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("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
}
)
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'])
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)
# 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.
# Send ping, check that ping get reply.
openstack.create_and_assign_floating_ip(os_conn=os_conn)
srv_list = os_conn.get_servers()
controlers = self.fuel_web.get_devops_nodes_by_nailgun_nodes(
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'))
controllers = self.fuel_web.get_devops_nodes_by_nailgun_nodes(
self.fuel_web.get_nailgun_cluster_nodes_by_roles(
cluster_id=cluster_id,
roles=['controller']))
ssh_controller = self.fuel_web.get_ssh_for_node(controlers[0].name)
openstack.check_connection_vms(
os_conn=os_conn,
srv_list=srv_list,
remote=ssh_controller
)
cmds = ['nova-manage service list | grep vcenter-vmcluster1',
'nova-manage service list | grep vcenter-vmcluster2']
openstack.check_service(ssh=ssh_controller, commands=cmds)
with self.fuel_web.get_ssh_for_node(controllers[0].name) as ssh_contr:
openstack.check_service(ssh=ssh_contr, commands=self.cmds)
openstack.check_connection_vms(
os_conn, floating_ip, remote=ssh_contr,
command='pingv4')
self.fuel_web.warm_shutdown_nodes(
[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.
# Send ping Check that ping get reply.
srv_list = os_conn.get_servers()
openstack.check_connection_vms(
os_conn=os_conn, srv_list=srv_list,
remote=ssh_controller
)
with self.fuel_web.get_ssh_for_node(controllers[1].name) as ssh_contr:
openstack.check_service(ssh=ssh_contr, commands=self.cmds)
openstack.check_connection_vms(
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.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_TENANT
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 tests.test_plugin_vmware_dvs_smoke import TestDVSSmoke
from helpers import openstack
from helpers import plugin
from proboscis import test
@ -54,7 +51,7 @@ class TestDVSMaintenance(TestBasic):
"""Get node by name."""
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"])
@log_snapshot_after_test
def dvs_regression(self):
@ -64,9 +61,9 @@ class TestDVSMaintenance(TestBasic):
1. Upload plugins to the master node
2. Install plugin.
3. Create cluster with vcenter.
4. Add 3 node with controller+mongo+cinder-vmware role.
5. Add 2 node with compute role.
6. Add 1 node with compute-vmware role.
4. Add 3 node with controller role.
5. Add 2 node with compute + ceph role.
6. Add 1 node with compute-vmware + cinder vmware role.
7. Deploy the cluster.
8. Run OSTF.
9. Create non default network.
@ -77,69 +74,38 @@ class TestDVSMaintenance(TestBasic):
Duration: 1.8 hours
"""
self.env.revert_snapshot("ready_with_9_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', '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'])
self.env.revert_snapshot("dvs_bvt")
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)
tenant = os_conn.get_tenant(SERVTEST_TENANT)
# Create non default network with subnet.
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]))
subnet = openstack.create_subnet(
os_conn,
network,
self.net_data[0][self.net_data[0].keys()[0]],
tenant_name=SERVTEST_TENANT
)
network = os_conn.create_network(
network_name=self.net_data[0].keys()[0],
tenant_id=tenant.id)['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]],
ip_version=4)
# Check that network are created.
assert_true(
os_conn.get_network(network['name'])['id'] == network['id']
)
# Add net_1 to default router
router = os_conn.get_router(os_conn.get_network(self.ext_net_name))
openstack.add_subnet_to_router(
os_conn,
router['id'], subnet['id'])
os_conn.add_router_interface(
router_id=router["id"],
subnet_id=subnet["id"])
# Launch instance 2 VMs of vcenter and 2 VMs of nova
# in the tenant network net_01
openstack.create_instances(
@ -149,11 +115,11 @@ class TestDVSMaintenance(TestBasic):
# Launch instance 2 VMs of vcenter and 2 VMs of nova
# in the default network
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,
nics=[{'net-id': network.id}])
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.
# Add Ingress rule for ICMP protocol to SG_1
# 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(sg2.id)
time.sleep(20) # need wait to update rules on dvs
fip = openstack.create_and_assign_floating_ips(os_conn, instances)
# Check ping between VMs
controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0]
)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_controller:
openstack.check_connection_vms(
os_conn=os_conn, srv_list=srv_list,
remote=ssh_controller)
os_conn, fip, 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
* Compute
* CephOSD
* CephOSD
* CinderVMware
* ComputeVMware
* Compute + CephOSD
* Compute + CephOSD
* Compute + CephOSD
* CinderVMware + ComputeVMware
5. Configure interfaces on nodes.
6. Configure network settings.
7. Enable and configure DVS plugin.
@ -163,16 +162,14 @@ class TestDVSSmoke(TestBasic):
{'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['compute-vmware'],
'slave-06': ['cinder-vmware'],
'slave-07': ['ceph-osd'],
'slave-08': ['ceph-osd'],
'slave-09': ['ceph-osd']}
'slave-04': ['compute', 'ceph-osd'],
'slave-05': ['compute', 'ceph-osd'],
'slave-06': ['compute', 'ceph-osd'],
'slave-07': ['compute-vmware', 'cinder-vmware']}
)
# 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(
cluster_id,
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.deploy_cluster_wait(cluster_id)
self.fuel_web.deploy_cluster_wait(cluster_id, timeout=3600 * 3)
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke'])
self.env.make_snapshot("dvs_bvt", is_make=True)
@test(depends_on=[SetupEnvironment.prepare_slaves_1],
groups=["dvs_install", "dvs_vcenter_plugin"])
@log_snapshot_after_test
@ -246,6 +245,9 @@ class TestDVSSmoke(TestBasic):
cmd = 'fuel plugins --remove {0}=={1}'.format(
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)
cmd = 'fuel plugins list'
output = list(self.env.d_env.get_admin_remote().execute(
@ -253,5 +255,5 @@ class TestDVSSmoke(TestBasic):
assert_true(
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.show_step(1)
self.show_step(2)
plugin.install_dvs_plugin(
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(
name=self.__class__.__name__,
mode=DEPLOYMENT_MODE,
@ -104,7 +106,9 @@ class TestDVSSystem(TestBasic):
)
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(
cluster_id,
{'slave-01': ['controller'],
@ -123,11 +127,14 @@ class TestDVSSystem(TestBasic):
vc_glance=True
)
self.show_step(7)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(8)
self.fuel_web.run_ostf(
cluster_id=cluster_id, test_sets=['smoke'])
self.show_step(9)
self.env.make_snapshot("dvs_vcenter_systest_setup", is_make=True)
@test(depends_on=[dvs_vcenter_systest_setup],
@ -147,11 +154,12 @@ class TestDVSSystem(TestBasic):
Duration: 15 min
"""
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup")
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_conn = os_actions.OpenStackActions(
os_ip, SERVTEST_USERNAME,
@ -160,49 +168,52 @@ class TestDVSSystem(TestBasic):
subnets = []
networks = []
tenant = os_conn.get_tenant(SERVTEST_TENANT)
for net in self.net_data:
logger.info('Create network {}'.format(net.keys()[0]))
network = openstack.create_network(
os_conn,
net.keys()[0], tenant_name=SERVTEST_TENANT
)
network = os_conn.create_network(
network_name=net.keys()[0],
tenant_id=tenant.id)['network']
logger.info('Create subnet {}'.format(net.keys()[0]))
subnet = openstack.create_subnet(
os_conn,
network,
net[net.keys()[0]], tenant_name=SERVTEST_TENANT
)
subnet = os_conn.create_subnet(
subnet_name=net.keys()[0],
network_id=network['id'],
cidr=net[net.keys()[0]],
ip_version=4)
subnets.append(subnet)
networks.append(network)
# Check that networks are created.
self.show_step(3)
for network in networks:
assert_true(
os_conn.get_network(network['name'])['id'] == network['id']
)
# Delete net_1.
self.show_step(4)
logger.info('Delete network net_1')
os_conn.neutron.delete_subnet(subnets[0]['id'])
os_conn.neutron.delete_network(networks[0]['id'])
# Check that net_1 is deleted.
self.show_step(5)
assert_true(
os_conn.get_network(networks[0]) is None
)
logger.info('Networks net_1 is removed.')
logger.info('Created net_1 again.')
network = openstack.create_network(
os_conn,
self.net_data[0].keys()[0])
subnet = openstack.create_subnet(
os_conn,
network,
self.net_data[0][self.net_data[0].keys()[0]],
tenant_name=SERVTEST_TENANT
)
self.show_step(6)
network = os_conn.create_network(
network_name=self.net_data[0].keys()[0],
tenant_id=tenant.id)['network']
logger.info('Create subnet {}'.format(net.keys()[0]))
subnet = os_conn.create_subnet(
subnet_name=self.net_data[0].keys()[0],
network_id=network['id'],
cidr=self.net_data[0][self.net_data[0].keys()[0]],
ip_version=4)
assert_true(
os_conn.get_network(network['name'])['id'] == network['id']
)
@ -230,71 +241,64 @@ class TestDVSSystem(TestBasic):
Duration: 15 min
"""
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster()
# Create new network
os_ip = self.fuel_web.get_public_vip(cluster_id)
os_conn = os_actions.OpenStackActions(
os_ip, SERVTEST_USERNAME,
SERVTEST_PASSWORD,
SERVTEST_TENANT)
# Create non default network with subnet.
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
)
tenant = os_conn.get_tenant(SERVTEST_TENANT)
logger.info('Create subnet {}'.format(self.net_data[0].keys()[0]))
subnet = openstack.create_subnet(
os_conn,
network,
self.net_data[0][self.net_data[0].keys()[0]],
tenant_name=SERVTEST_TENANT
)
self.show_step(2)
network = os_conn.create_network(
network_name=self.net_data[0].keys()[0],
tenant_id=tenant.id)['network']
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.
assert_true(
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
security_group = os_conn.create_sec_group_for_ssh()
# Launch instance VM_1, VM_2 in the tenant network net_01
# with image TestVMDK and flavor m1.micro in the nova az.
# Launch instances VM_3 and VM_4 in the net01
# with image TestVM-VMDK and flavor m1.micro in vcenter az.
openstack.create_instances(
self.show_step(5)
self.show_step(6)
instances = 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)
# Add net_1 to default router
router = os_conn.get_router(os_conn.get_network(self.ext_net_name))
openstack.add_subnet_to_router(
os_conn,
router['id'], subnet['id'])
# Get floating ip of instances.
fip = openstack.create_and_assign_floating_ips(os_conn, instances)
openstack.create_and_assign_floating_ip(os_conn=os_conn)
# 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.show_step(7)
controller = self.fuel_web.get_nailgun_primary_node(
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=os_conn, srv_list=srv_list, command='pingv4',
remote=ssh_controller,
destination_ip=['8.8.8.8']
)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
openstack.check_connection_vms(
os_conn, fip, remote=ssh_contr,
command='pingv4', destination_ip=['8.8.8.8'])
@test(depends_on=[dvs_vcenter_systest_setup],
groups=["dvs_instances_one_group", 'dvs_vcenter_system'])
@ -316,6 +320,7 @@ class TestDVSSystem(TestBasic):
Duration: 15 min
"""
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup")
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()
# 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(
[os_conn.nova.hypervisors.resource_class.to_dict(h)['vcpus']
for h in os_conn.nova.hypervisors.list()]
)
logger.info(security_group)
self.show_step(2)
self.show_step(3)
openstack.create_instances(
os_conn=os_conn, nics=[{'net-id': network.id}],
vm_count=vm_count, security_groups=[security_group.name]
)
openstack.verify_instance_state(os_conn)
logger.info("Check ping is available between instances.")
openstack.create_and_assign_floating_ip(os_conn=os_conn)
self.show_step(4)
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])
ssh_controller = self.fuel_web.get_ssh_for_node(
primary_controller.name)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
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_1, ip_2)
for ip_1 in floating_ip
for ip_2 in floating_ip
for ip_1 in fip
for ip_2 in fip
if ip_1 != ip_2]
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:
os_conn.nova.servers.delete(srv)
@ -445,6 +441,7 @@ class TestDVSSystem(TestBasic):
"protocol": "icmp",
"security_group_id": ""}}
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster()
@ -457,8 +454,7 @@ class TestDVSSystem(TestBasic):
tenant = os_conn.get_tenant(SERVTEST_TENANT)
logger.info("Create non default network with subnet.")
logger.info('Create network {}'.format(self.net_data[0].keys()[0]))
self.show_step(2)
network = os_conn.create_network(
network_name=self.net_data[0].keys()[0],
tenant_id=tenant.id)['network']
@ -480,8 +476,7 @@ class TestDVSSystem(TestBasic):
router_id=router["id"],
subnet_id=subnet["id"])
logger.info("""Launch 2 instances of vcenter and 2 instances of nova
in the tenant network net_01.""")
self.show_step(3)
openstack.create_instances(
os_conn=os_conn,
nics=[{'net-id': network['id']}],
@ -489,9 +484,7 @@ class TestDVSSystem(TestBasic):
)
openstack.verify_instance_state(os_conn)
logger.info("""Launch 2 instances of vcenter and
2 instances of nova
in the default tenant network.""")
self.show_step(4)
network = os_conn.nova.networks.find(label=self.inter_net_name)
openstack.create_instances(
os_conn=os_conn,
@ -501,25 +494,18 @@ class TestDVSSystem(TestBasic):
openstack.verify_instance_state(os_conn)
srv_list = os_conn.get_servers()
floating_ip = []
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.""")
self.show_step(5)
sec_name = ['SG1', 'SG2']
sg1 = os_conn.nova.security_groups.create(
sec_name[0], "descr")
sg2 = os_conn.nova.security_groups.create(
sec_name[1], "descr")
self.show_step(6)
tcp["security_group_rule"]["security_group_id"] = sg1.id
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
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(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.")
primary_controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0]
)
ssh_controller = self.fuel_web.get_ssh_for_node(
primary_controller.name)
self.show_step(9)
controller = self.fuel_web.get_nailgun_primary_node(
self.env.d_env.nodes().slaves[0])
logger.info("Check ping is available between instances.")
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list,
command='pingv4', remote=ssh_controller)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
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(10)
ip_pair = [(ip_1, ip_2)
for ip_1 in floating_ip
for ip_2 in floating_ip
if ip_1 != ip_2]
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()[
'security_group_rules']
sg_rules = [
@ -566,7 +551,7 @@ class TestDVSSystem(TestBasic):
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:
try:
openstack.get_ssh_connection(
@ -575,7 +560,7 @@ class TestDVSSystem(TestBasic):
except Exception as 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
os_conn.neutron.create_security_group_rule(tcp)
tcp["security_group_rule"]["direction"] = "egress"
@ -583,15 +568,17 @@ class TestDVSSystem(TestBasic):
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:
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.")
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list,
command='pingv4', remote=ssh_controller,
result_of_command=1)
self.show_step(15)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
openstack.check_connection_vms(
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")
icmp["security_group_rule"]["security_group_id"] = sg1.id
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
logger.info("Check ping is available between instances.")
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list,
command='pingv4', remote=ssh_controller)
self.show_step(17)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
openstack.check_connection_vms(
os_conn, floating_ip, remote=ssh_contr,
command='pingv4')
logger.info("""Delete SG1 and SG2 security groups.
Attach instances to default security group.""")
self.show_step(21)
self.show_step(22)
srv_list = os_conn.get_servers()
for srv in srv_list:
for sg in srv.security_groups:
@ -623,13 +612,15 @@ class TestDVSSystem(TestBasic):
os_conn.neutron.create_security_group_rule(tcp)
time.sleep(20) # need wait to update rules on dvs ports
logger.info("Check ping is available between instances.")
openstack.check_connection_vms(os_conn=os_conn, srv_list=srv_list,
command='pingv4', remote=ssh_controller)
self.show_step(23)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
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:
openstack.check_ssh_between_instances(ips[0], ips[1])
openstack.remote_execute_command(ips[0], ips[1], ' ')
@test(depends_on=[dvs_vcenter_systest_setup],
groups=["dvs_vcenter_tenants_isolation", 'dvs_vcenter_system'])
@ -655,103 +646,87 @@ class TestDVSSystem(TestBasic):
Duration: 30 min
"""
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster()
# Create new network
os_ip = self.fuel_web.get_public_vip(cluster_id)
admin = os_actions.OpenStackActions(
os_ip, SERVTEST_USERNAME,
SERVTEST_PASSWORD,
SERVTEST_TENANT)
# Create non-admin tenant.
self.show_step(2)
admin.create_user_and_tenant('test', 'test', 'test')
openstack.add_role_to_user(admin, 'test', 'admin', 'test')
test = os_actions.OpenStackActions(
os_ip, 'test', 'test', 'test')
# Create non default network with subnet in test tenant.
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'
)
tenant = test.get_tenant('test')
logger.info('Create subnet {}'.format(self.net_data[0].keys()[0]))
subnet = openstack.create_subnet(
test,
network,
self.net_data[0][self.net_data[0].keys()[0]],
tenant_name='test'
)
self.show_step(3)
network_test = test.create_network(
network_name=self.net_data[0].keys()[0],
tenant_id=tenant.id)['network']
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
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
openstack.create_instances(
os_conn=test, vm_count=1,
nics=[{'net-id': network['id']}],
security_groups=[security_group.name]
)
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'])
self.show_step(4)
router = test.create_router('router_1', tenant=tenant)
test.add_router_interface(
router_id=router["id"],
subnet_id=subnet_test["id"])
# create security group with rules for ssh and ping
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)
openstack.create_instances(
srv_1 = openstack.create_instances(
os_conn=admin, nics=[{'net-id': network.id}], vm_count=1,
security_groups=[security_group.name])
openstack.verify_instance_state(admin)
# Send ping from instances VM_1 and VM_2 to VM_3 and VM_4
# via no floating ip
srv_1 = admin.get_servers()
srv_2 = test.get_servers()
openstack.create_and_assign_floating_ip(os_conn=admin, srv_list=srv_1)
openstack.create_and_assign_floating_ip(
os_conn=test,
srv_list=srv_2,
ext_net=None,
tenant_id=test.get_tenant('test').id)
self.show_step(6)
srv_2 = openstack.create_instances(
os_conn=test, vm_count=1,
nics=[{'net-id': network_test['id']}],
security_groups=[security_group_test.name]
)
openstack.verify_instance_state(test)
srv_1 = admin.get_servers()
srv_2 = test.get_servers()
self.show_step(7)
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:
ip = srv.networks[srv.networks.keys()[0]][0]
ips.append(ip)
ips_2.append(test.get_nova_instance_ip(
srv, net_name=network_test['name']))
logger.info(ips)
logger.info(srv_1)
primary_controller = self.fuel_web.get_nailgun_primary_node(
controller = self.fuel_web.get_nailgun_primary_node(
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=admin, srv_list=srv_1, command='pingv4',
result_of_command=1,
remote=ssh_controller, destination_ip=ips
)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
openstack.check_connection_vms(
admin, fip_1, remote=ssh_contr,
command='pingv4', destination_ip=ips_2, result_of_command=1)
openstack.check_connection_vms(
admin, fip_2, remote=ssh_contr,
command='pingv4', destination_ip=ips_1, result_of_command=1)
@test(depends_on=[dvs_vcenter_systest_setup],
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.
4. Create Router_01, set gateway and add interface
to external network.
5. Create private network net01 with subnet in default admin tenant
6. Create Router_01, set gateway and add interface
to external network.
7. Launch instances VM_1 and VM_2
5. Launch instances VM_1 and VM_2
in the net01(non-admin tenant)
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.
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
in the net01(default admin tenant)
with image TestVM and flavor m1.micro in nova az.
@ -787,6 +762,7 @@ class TestDVSSystem(TestBasic):
Duration: 30 min
"""
self.show_step(1)
self.env.revert_snapshot("dvs_vcenter_systest_setup")
cluster_id = self.fuel_web.get_last_created_cluster()
@ -797,119 +773,99 @@ class TestDVSSystem(TestBasic):
SERVTEST_PASSWORD,
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')
openstack.add_role_to_user(admin, 'test', 'admin', 'test')
test = os_actions.OpenStackActions(
os_ip, 'test', 'test', 'test')
# Create non default network with subnet in test tenant.
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'
)
tenant = test.get_tenant('test')
logger.info('Create subnet {}'.format(self.net_data[0].keys()[0]))
subnet = openstack.create_subnet(
test,
network,
self.net_data[0][self.net_data[0].keys()[0]],
tenant_name='test'
)
self.show_step(3)
logger.info('Create network {}'.format(self.net_data[0].keys()[0]))
network = test.create_network(
network_name=self.net_data[0].keys()[0],
tenant_id=tenant.id)['network']
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
security_group = test.create_sec_group_for_ssh()
# Launch instances VM_1 and VM_2 in the net01(non-admin tenant)
# with image TestVM and flavor m1.micro in nova az.
# Launch instances VM_3 and VM_4 in the net01(non-admin tenant)
# with image TestVM-VMDK and flavor m1.micro in vcenter az.
openstack.create_instances(
self.show_step(5)
self.show_step(6)
srv_1 = openstack.create_instances(
os_conn=test, nics=[{'net-id': network['id']}], vm_count=1,
security_groups=[security_group.name]
)
openstack.verify_instance_state(test)
# Create Router_01, set gateway and add interface
# to external network.
router_1 = openstack.add_router(
test,
'router_1',
ext_net_name=self.ext_net_name, tenant_name='test'
)
fip_1 = openstack.create_and_assign_floating_ips(test, srv_1)
ips_1 = []
for srv in srv_1:
ips_1.append(test.get_nova_instance_ip(
srv, net_name=network['name']))
# 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
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]))
network = openstack.create_network(
admin,
self.net_data[0].keys()[0])
network = admin.create_network(
network_name=self.net_data[0].keys()[0],
tenant_id=tenant_admin.id)['network']
logger.info('Create subnet {}'.format(self.net_data[0].keys()[0]))
subnet = openstack.create_subnet(
admin,
network,
self.net_data[0][self.net_data[0].keys()[0]])
subnet = admin.create_subnet(
subnet_name=network['name'],
network_id=network['id'],
cidr=self.net_data[0][self.net_data[0].keys()[0]],
ip_version=4)
# Launch instances VM_5 and VM_6
# in the net01(default admin tenant)
# with image TestVM and flavor m1.micro in nova az.
# Launch instances VM_7 and VM_8
# in the net01(default admin tenant)
# with image TestVM-VMDK and flavor m1.micro in vcenter az.
openstack.create_instances(
self.show_step(8)
router = admin.create_router('router_1', tenant=tenant)
admin.add_router_interface(
router_id=router["id"],
subnet_id=subnet["id"])
self.show_step(9)
self.show_step(10)
srv_2 = openstack.create_instances(
os_conn=admin, nics=[{'net-id': network['id']}], vm_count=1,
security_groups=[security_group.name])
openstack.verify_instance_state(admin)
# Create Router_01, set gateway and add interface
# to external network.
router_1 = openstack.add_router(
admin,
'router_1')
self.show_step(11)
self.show_step(12)
fip_2 = openstack.create_and_assign_floating_ips(admin, srv_2)
ips_2 = []
for srv in srv_2:
ips_2.append(admin.get_nova_instance_ip(
srv, net_name=network['name']))
# Add net_1 to router_1
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(
controller = self.fuel_web.get_nailgun_primary_node(
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
# between each other via fixed ip.
openstack.check_connection_vms(os_conn=admin, srv_list=srv_2,
remote=ssh_controller)
with self.fuel_web.get_ssh_for_node(controller.name) as ssh_contr:
openstack.check_connection_vms(
test, fip_1, remote=ssh_contr,
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],
groups=["dvs_volume", 'dvs_vcenter_system'])
@ -1471,10 +1427,9 @@ class TestDVSSystem(TestBasic):
map_router_subnet[1]['router'],
{"subnet_id": map_router_subnet[1]['subnet']})
openstack.add_subnet_to_router(
admin,
map_router_subnet[0]['router'],
map_router_subnet[1]['subnet'])
admin.add_router_interface(
router_id=map_router_subnet[0]['router'],
subnet_id=map_router_subnet[1]['subnet'])
time.sleep(20) # need wait to port state update
self.show_step(14)
for ip in instances_group[1]['private_ips']: