def update_node_interfaces(self, node_id):
interfaces = self.download_node_interfaces(node_id)
logger.debug("interfaces we get {}".format(interfaces))
assigned_networks = {
iface_alias('eth0'): [{
'id': 1,
'name': 'fuelweb_admin'
}],
iface_alias('eth1'): [{
'id': 2,
'name': 'public'
}],
iface_alias('eth2'): [{
'id': 3,
'name': 'management'
}],
iface_alias('eth3'): [{
'id': 5,
'name': 'private'
}],
iface_alias('eth4'): [{
'id': 4,
'name': 'storage'
}],
}
for interface in interfaces:
name = interface['name']
net_to_assign = assigned_networks.get(name, None)
if net_to_assign:
interface['assigned_networks'] = net_to_assign
logger.debug("interfaces after update {}".format(interfaces))
self.upload_node_interfaces(node_id, interfaces)
def test_untagged_networks_negative(self):
"""Verify network verification fails with untagged network on eth0
Scenario:
1. Create cluster in ha mode
2. Add 1 node with controller role
3. Add 1 node with compute role
4. Add 1 node with compute cinder
5. Split networks on existing physical interfaces
6. Remove VLAN tagging from networks which are on eth0
7. Run network verification (assert it fails)
8. Start cluster deployment (assert it fails)
Duration 30m
"""
fuel_web = self.manager.fuel_web
vlan_turn_off = {'vlan_start': None}
interfaces = {
iface_alias('eth0'): ["fixed"],
iface_alias('eth1'): ["public"],
iface_alias('eth2'): ["management", "storage"],
iface_alias('eth3'): []
}
self.manager.show_step(1)
cluster_id = fuel_web.create_cluster(
name=self.cluster_config['name'],
mode=self.cluster_config['mode'],
)
self.manager.show_step(2)
self.manager.show_step(3)
self.manager.show_step(4)
fuel_web.update_nodes(
cluster_id,
self.cluster_config['nodes']
)
self.manager.show_step(5)
nets = fuel_web.client.get_networks(cluster_id)['networks']
nailgun_nodes = fuel_web.client.list_cluster_nodes(cluster_id)
for node in nailgun_nodes:
fuel_web.update_node_networks(node['id'], interfaces)
self.manager.show_step(6)
# select networks that will be untagged:
for net in nets:
net.update(vlan_turn_off)
# stop using VLANs:
fuel_web.client.update_network(cluster_id, networks=nets)
self.manager.show_step(7)
# run network check:
fuel_web.verify_network(cluster_id, success=False)
self.manager.show_step(8)
# deploy cluster:
task = fuel_web.deploy_cluster(cluster_id)
fuel_web.assert_task_failed(task)
def untagged_networks_negative(self):
"""Verify network verification fails with untagged network on eth0
Test disabled and move to fuel_tests suite:
fuel_tests.test.test_l2_network_config.TestL2NetworkConfig
Scenario:
1. Create cluster in ha mode
2. Add 1 node with controller role
3. Add 1 node with compute role
4. Split networks on existing physical interfaces
5. Remove VLAN tagging from networks which are on eth0
6. Run network verification (assert it fails)
7. Start cluster deployment (assert it fails)
Duration 30m
"""
# pylint: disable=W0101
warn("Test disabled and move to fuel_tests suite", DeprecationWarning)
raise SkipTest("Test disabled and move to fuel_tests suite")
self.env.revert_snapshot("ready_with_3_slaves")
vlan_turn_off = {'vlan_start': None}
interfaces = {
iface_alias('eth0'): ["fixed"],
iface_alias('eth1'): ["public"],
iface_alias('eth2'): ["management", "storage"],
iface_alias('eth3'): []
}
cluster_id = self.fuel_web.create_cluster(name=self.__class__.__name__,
mode=DEPLOYMENT_MODE)
self.fuel_web.update_nodes(cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute']
})
nets = self.fuel_web.client.get_networks(cluster_id)['networks']
nailgun_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in nailgun_nodes:
self.fuel_web.update_node_networks(node['id'], interfaces)
# select networks that will be untagged:
for net in nets:
net.update(vlan_turn_off)
# stop using VLANs:
self.fuel_web.client.update_network(cluster_id, networks=nets)
# run network check:
self.fuel_web.verify_network(cluster_id, success=False)
# deploy cluster:
task = self.fuel_web.deploy_cluster(cluster_id)
self.fuel_web.assert_task_failed(task)
def deploy_node_multiple_interfaces(self):
"""Deploy cluster with networks allocated on different interfaces
Test disabled and move to fuel_tests suite:
fuel_tests.test.test_l2_network_config.TestL2NetworkConfig
Scenario:
1. Create cluster in Ha mode
2. Add 1 node with controller role
3. Add 1 node with compute role
4. Add 1 node with cinder role
5. Split networks on existing physical interfaces
6. Deploy the cluster
7. Verify network configuration on each deployed node
8. Run network verification
Duration 25m
Snapshot: deploy_node_multiple_interfaces
"""
# pylint: disable=W0101
warn("Test disabled and move to fuel_tests suite", DeprecationWarning)
raise SkipTest("Test disabled and move to fuel_tests suite")
self.env.revert_snapshot("ready_with_3_slaves")
interfaces_dict = {
iface_alias('eth0'): ['fuelweb_admin'],
iface_alias('eth1'): ['public'],
iface_alias('eth2'): ['storage'],
iface_alias('eth3'): ['private'],
iface_alias('eth4'): ['management'],
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=DEPLOYMENT_MODE,
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
}
)
nailgun_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in nailgun_nodes:
self.fuel_web.update_node_networks(node['id'], interfaces_dict)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.verify_network(cluster_id)
self.env.make_snapshot("deploy_node_multiple_interfaces", is_make=True)
def untagged_networks_negative(self):
"""Verify network verification fails with untagged network on eth0
Scenario:
1. Create cluster in ha mode
2. Add 1 node with controller role
3. Add 1 node with compute role
4. Split networks on existing physical interfaces
5. Remove VLAN tagging from networks which are on eth0
6. Run network verification (assert it fails)
7. Start cluster deployment (assert it fails)
Duration 30m
"""
self.env.revert_snapshot("ready_with_3_slaves")
vlan_turn_off = {'vlan_start': None}
interfaces = {
iface_alias('eth0'): ["fixed"],
iface_alias('eth1'): ["public"],
iface_alias('eth2'): ["management", "storage"],
iface_alias('eth3'): []
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=DEPLOYMENT_MODE
)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute']
}
)
nets = self.fuel_web.client.get_networks(cluster_id)['networks']
nailgun_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in nailgun_nodes:
self.fuel_web.update_node_networks(node['id'], interfaces)
# select networks that will be untagged:
for net in nets:
net.update(vlan_turn_off)
# stop using VLANs:
self.fuel_web.client.update_network(cluster_id, networks=nets)
# run network check:
self.fuel_web.verify_network(cluster_id, success=False)
# deploy cluster:
task = self.fuel_web.deploy_cluster(cluster_id)
self.fuel_web.assert_task_failed(task)
def deploy_node_multiple_interfaces(self):
"""Deploy cluster with networks allocated on different interfaces
Test disabled and move to fuel_tests suite:
fuel_tests.test.test_l2_network_config.TestL2NetworkConfig
Scenario:
1. Create cluster in Ha mode
2. Add 1 node with controller role
3. Add 1 node with compute role
4. Add 1 node with cinder role
5. Split networks on existing physical interfaces
6. Deploy the cluster
7. Verify network configuration on each deployed node
8. Run network verification
Duration 25m
Snapshot: deploy_node_multiple_interfaces
"""
# pylint: disable=W0101
warn("Test disabled and move to fuel_tests suite", DeprecationWarning)
raise SkipTest("Test disabled and move to fuel_tests suite")
self.env.revert_snapshot("ready_with_3_slaves")
interfaces_dict = {
iface_alias('eth0'): ['fuelweb_admin'],
iface_alias('eth1'): ['public'],
iface_alias('eth2'): ['storage'],
iface_alias('eth3'): ['private'],
iface_alias('eth4'): ['management'],
}
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=DEPLOYMENT_MODE,
)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
})
nailgun_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in nailgun_nodes:
self.fuel_web.update_node_networks(node['id'], interfaces_dict)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.verify_network(cluster_id)
self.env.make_snapshot("deploy_node_multiple_interfaces", is_make=True)
def check_can_not_enable_dpdk_on_non_dedicated_iface(self):
"""Check can not enable DPDK on non-dedicated interface
Scenario:
1. Create new environment with VLAN segmentation for Neutron
2. Set KVM as Hypervisor
3. Add controller and compute nodes
4. Configure HugePages for compute nodes
5. Add private and storage networks to interface
and try enable DPDK mode
"""
self.env.revert_snapshot("ready_with_3_slaves")
self.show_step(1)
self.show_step(2)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
"net_provider": 'neutron',
"net_segment_type": "vlan"
}
)
self.show_step(3)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
})
compute = self.fuel_web.get_nailgun_cluster_nodes_by_roles(
cluster_id, ['compute'], role_status='pending_roles')[0]
self.show_step(4)
self.setup_hugepages(compute, hp_2mb=256, hp_dpdk_mb=128)
self.show_step(5)
assigned_networks = {
settings.iface_alias('eth0'): ['fuelweb_admin'],
settings.iface_alias('eth1'): ['public'],
settings.iface_alias('eth2'): ['management'],
settings.iface_alias('eth3'): ['private', 'storage'],
settings.iface_alias('eth4'): []
}
self.fuel_web.update_node_networks(compute['id'],
interfaces_dict=assigned_networks)
assert_raises(
exceptions.BadRequest,
self.enable_dpdk, compute,
forceEnable=True)
def test_deploy_node_multiple_interfaces(self):
"""Deploy cluster with networks allocated on different interfaces
Scenario:
1. Create cluster in Ha mode
2. Add 1 node with controller role
3. Add 1 node with compute role
4. Add 1 node with cinder role
5. Split networks on existing physical interfaces
6. Deploy the cluster
7. Verify network configuration on each deployed node
8. Run network verification
Duration 25m
Snapshot: deploy_node_multiple_interfaces
"""
# self.env.revert_snapshot("ready_with_3_slaves")
fuel_web = self.manager.fuel_web
interfaces_dict = {
iface_alias('eth0'): ['fuelweb_admin'],
iface_alias('eth1'): ['public'],
iface_alias('eth2'): ['storage'],
iface_alias('eth3'): ['private'],
iface_alias('eth4'): ['management'],
}
self.manager.show_step(1)
cluster_id = fuel_web.create_cluster(
name=self.cluster_config['name'],
mode=self.cluster_config['mode'],
)
self.manager.show_step(2)
self.manager.show_step(3)
self.manager.show_step(4)
fuel_web.update_nodes(
cluster_id,
self.cluster_config['nodes']
)
self.manager.show_step(5)
nailgun_nodes = fuel_web.client.list_cluster_nodes(cluster_id)
for node in nailgun_nodes:
fuel_web.update_node_networks(node['id'], interfaces_dict)
self.manager.show_step(6)
fuel_web.deploy_cluster_wait(cluster_id)
self.manager.show_step(7)
fuel_web.verify_network(cluster_id)
def test_deploy_node_multiple_interfaces(self):
"""Deploy cluster with networks allocated on different interfaces
Scenario:
1. Create cluster in Ha mode
2. Add 1 node with controller role
3. Add 1 node with compute role
4. Add 1 node with cinder role
5. Split networks on existing physical interfaces
6. Deploy the cluster
7. Verify network configuration on each deployed node
8. Run network verification
Duration 25m
Snapshot: deploy_node_multiple_interfaces
"""
# self.env.revert_snapshot("ready_with_3_slaves")
fuel_web = self.manager.fuel_web
interfaces_dict = {
iface_alias('eth1'): ['public'],
iface_alias('eth2'): ['storage'],
iface_alias('eth3'): ['private'],
iface_alias('eth4'): ['management'],
}
self.manager.show_step(1)
cluster_id = fuel_web.create_cluster(
name=self.cluster_config['name'],
mode=self.cluster_config['mode'],
)
self.manager.show_step(2)
self.manager.show_step(3)
self.manager.show_step(4)
fuel_web.update_nodes(
cluster_id,
self.cluster_config['nodes']
)
self.manager.show_step(5)
nailgun_nodes = fuel_web.client.list_cluster_nodes(cluster_id)
for node in nailgun_nodes:
fuel_web.update_node_networks(node['id'], interfaces_dict)
self.manager.show_step(6)
fuel_web.deploy_cluster_wait(cluster_id)
self.manager.show_step(7)
fuel_web.verify_network(cluster_id)
def update_node_interfaces(self, node_id):
interfaces = self.download_node_interfaces(node_id)
logger.debug("interfaces we get {}".format(interfaces))
assigned_networks = {
iface_alias('eth0'): [{'id': 1, 'name': 'fuelweb_admin'}],
iface_alias('eth1'): [{'id': 2, 'name': 'public'}],
iface_alias('eth2'): [{'id': 3, 'name': 'management'}],
iface_alias('eth3'): [{'id': 5, 'name': 'private'}],
iface_alias('eth4'): [{'id': 4, 'name': 'storage'}],
}
for interface in interfaces:
name = interface['name']
net_to_assign = assigned_networks.get(name, None)
if net_to_assign:
interface['assigned_networks'] = net_to_assign
logger.debug("interfaces after update {}".format(interfaces))
self.upload_node_interfaces(node_id, interfaces)
def update_node_interfaces(self, node_id):
interfaces = self.download_node_interfaces(node_id)
logger.debug("interfaces we get {}".format(interfaces))
assigned_networks = {
iface_alias("eth0"): [{"id": 1, "name": "fuelweb_admin"}],
iface_alias("eth1"): [{"id": 2, "name": "public"}],
iface_alias("eth2"): [{"id": 3, "name": "management"}],
iface_alias("eth3"): [{"id": 5, "name": "private"}],
iface_alias("eth4"): [{"id": 4, "name": "storage"}],
}
for interface in interfaces:
name = interface["name"]
net_to_assign = assigned_networks.get(name, None)
if net_to_assign:
interface["assigned_networks"] = net_to_assign
logger.debug("interfaces after update {}".format(interfaces))
self.upload_node_interfaces(node_id, interfaces)
def dhcrelay_check(self):
# CentOS 7 is pretty stable with admin iface.
# TODO(akostrikov) refactor it.
iface = iface_alias("eth0")
command = "dhcpcheck discover " "--ifaces {iface} " "--repeat 3 " "--timeout 10".format(iface=iface)
out = self.ssh_manager.execute(ip=self.ssh_manager.admin_ip, cmd=command)["stdout"]
assert_true(self.get_admin_node_ip() in "".join(out), "dhcpcheck doesn't discover master ip")
def update_vm_node_interfaces(self, obj, cluster_id):
"""Update network interfaces for node."""
assigned_networks = {
iface_alias('eth0'): ['fuelweb_admin', 'storage', 'management'],
iface_alias('eth1'): ['public'],
iface_alias('eth3'): ['private'],
}
logger.info('Assigned networks are: {}'.format(str(assigned_networks)))
nailgun_nodes = obj.fuel_web.client.list_cluster_nodes(cluster_id)
baremetal_macs = self.conf['target_macs']
for node in nailgun_nodes:
if not node['status'] == 'discover':
# Skip not discovered nodes
continue
if node['mac'] in baremetal_macs:
# Skip Barematal node
continue
obj.fuel_web.update_node_networks(node['id'], assigned_networks)
def get_keys(self,
node,
custom=None,
build_images=None,
iso_connect_as='cdrom'):
params = {
'device_label':
settings.ISO_LABEL,
'iface':
iface_alias('eth0'),
'ip':
node.get_ip_address_by_network_name('admin'),
'mask':
self.d_env.get_network(name='admin').ip.netmask,
'gw':
self.d_env.get_default_gw(),
'hostname':
''.join((settings.FUEL_MASTER_HOSTNAME, settings.DNS_SUFFIX)),
'nat_interface':
'',
'nameserver':
settings.DNS,
'showmenu':
'yes' if settings.SHOW_FUELMENU else 'no',
'wait_for_external_config':
'yes',
'build_images':
'1' if build_images else '0',
'MASTER_NODE_EXTRA_PACKAGES':
settings.MASTER_NODE_EXTRA_PACKAGES
}
# TODO(akostrikov) add tests for menu items/kernel parameters
# TODO(akostrikov) refactor it.
if iso_connect_as == 'usb':
keys = (
"<Wait>\n" # USB boot uses boot_menu=yes for master node
"<F12>\n"
"2\n")
else: # cdrom is default
keys = ("<Wait>\n" "<Wait>\n" "<Wait>\n")
keys += (
"<Esc>\n"
"<Wait>\n"
"vmlinuz initrd=initrd.img"
" inst.ks=cdrom:LABEL=%(device_label)s:/ks.cfg"
" inst.repo=cdrom:LABEL=%(device_label)s:/"
" ip=%(ip)s::%(gw)s:%(mask)s:%(hostname)s"
":%(iface)s:off::: nameserver=%(nameserver)s"
" showmenu=%(showmenu)s\n"
" wait_for_external_config=%(wait_for_external_config)s"
" build_images=%(build_images)s\n"
" MASTER_NODE_EXTRA_PACKAGES='%(MASTER_NODE_EXTRA_PACKAGES)s'\n"
" <Enter>\n") % params
return keys
def setup_centos_master(self):
"""Create environment, bootstrap centos_master
and install fuel services
Snapshot "empty_centos"
1. bootstrap_centos_master
2. Download fuel_release from remote repository
3. install fuel_setup package
4. Install Fuel services by executing bootstrap_admin_node.sh
5. check Fuel services
"""
self.check_run("empty_centos")
self.show_step(1, initialize=True)
cloud_image_settings_path = os.path.join(
os.path.dirname(fuelweb_test.__file__),
'cloud_image_settings/cloud_settings.iso')
admin_net_object = self.env.d_env.get_network(
name=self.env.d_env.admin_net)
admin_network = admin_net_object.ip.network
admin_netmask = admin_net_object.ip.netmask
admin_ip = str(self.env.d_env.nodes(
).admin.get_ip_address_by_network_name(self.env.d_env.admin_net))
interface_name = settings.iface_alias("eth0")
gateway = self.env.d_env.router()
dns = settings.DNS
dns_ext = ''.join(settings.EXTERNAL_DNS)
hostname = ''.join((settings.FUEL_MASTER_HOSTNAME,
settings.DNS_SUFFIX))
user = settings.SSH_FUEL_CREDENTIALS['login']
password = settings.SSH_FUEL_CREDENTIALS['password']
generate_cloud_image_settings(cloud_image_settings_path, admin_network,
interface_name, admin_ip, admin_netmask,
gateway, dns, dns_ext,
hostname, user, password)
with TimeStat("bootstrap_centos_node", is_uniq=True):
admin = self.env.d_env.nodes().admin
logger.info(cloud_image_settings_path)
admin.disk_devices.get(
device='cdrom').volume.upload(cloud_image_settings_path)
self.env.d_env.start([admin])
logger.info("Waiting for Centos node to start up")
wait(lambda: admin.driver.node_active(admin), 60)
logger.info("Waiting for Centos node ssh ready")
self.env.wait_for_provisioning()
self.centos_setup_fuel(hostname)
self.env.make_snapshot("empty", is_make=True)
def __init__(self):
super(BondingTestDPDK, self).__init__()
self.BOND_CONFIG = [
{
'mac': None,
'mode': 'active-backup',
'name': 'bond0',
'slaves': [
{'name': iface_alias('eth3')},
{'name': iface_alias('eth2')}
],
'state': None,
'type': 'bond',
'assigned_networks': [],
'interface_properties': {'dpdk': {'available': True}},
'bond_properties': {'mode': 'active-backup',
'type__': 'linux'},
},
{
'mac': None,
'mode': 'active-backup',
'name': 'bond1',
'slaves': [
{'name': iface_alias('eth1')},
{'name': iface_alias('eth0')}
],
'state': None,
'type': 'bond',
'assigned_networks': [],
'interface_properties': {'dpdk': {'available': True}},
'bond_properties': {'mode': 'active-backup',
'type__': 'linux'},
},
{
'mac': None,
'mode': 'active-backup',
'name': 'bond2',
'slaves': [
{'name': iface_alias('eth5')},
{'name': iface_alias('eth4')},
],
'state': None,
'type': 'bond',
'assigned_networks': [],
'interface_properties': {'dpdk': {'available': True}},
'bond_properties': {'mode': 'active-backup',
'type__': 'linux'},
},
]
self.INTERFACES = {
'bond0': [
'public',
'management',
'storage',
],
'bond1': ['fuelweb_admin'],
'bond2': ['private'],
}
def dhcrelay_check(self):
# CentOS 7 is pretty stable with admin iface.
# TODO(akostrikov) refactor it.
iface = iface_alias('eth0')
command = "dhcpcheck discover " \
"--ifaces {iface} " \
"--repeat 3 " \
"--timeout 10".format(iface=iface)
out = self.ssh_manager.execute(ip=self.ssh_manager.admin_ip,
cmd=command)['stdout']
assert_true(self.get_admin_node_ip() in "".join(out),
"dhcpcheck doesn't discover master ip")
def get_keys(self, node, custom=None, build_images=None,
iso_connect_as='cdrom'):
params = {
'device_label': settings.ISO_LABEL,
'iface': iface_alias('eth0'),
'ip': node.get_ip_address_by_network_name(
self.d_env.admin_net),
'mask': self.d_env.get_network(
name=self.d_env.admin_net).ip.netmask,
'gw': self.d_env.router(),
'hostname': ''.join((settings.FUEL_MASTER_HOSTNAME,
settings.DNS_SUFFIX)),
'nat_interface': self.d_env.nat_interface,
'nameserver': settings.DNS,
'showmenu': 'yes' if settings.SHOW_FUELMENU else 'no',
'wait_for_external_config': 'yes',
'build_images': '1' if build_images else '0',
'MASTER_NODE_EXTRA_PACKAGES': settings.MASTER_NODE_EXTRA_PACKAGES
}
# TODO(akostrikov) add tests for menu items/kernel parameters
# TODO(akostrikov) refactor it.
if iso_connect_as == 'usb':
keys = (
"<Wait>\n" # USB boot uses boot_menu=yes for master node
"<F12>\n"
"2\n"
)
else: # cdrom is default
keys = (
"<Wait>\n"
"<Wait>\n"
"<Wait>\n"
)
keys += (
"<Esc>\n"
"<Wait>\n"
"vmlinuz initrd=initrd.img"
" inst.ks=cdrom:LABEL=%(device_label)s:/ks.cfg"
" inst.repo=cdrom:LABEL=%(device_label)s:/"
" ip=%(ip)s::%(gw)s:%(mask)s:%(hostname)s"
":%(iface)s:off::: nameserver=%(nameserver)s"
" showmenu=%(showmenu)s\n"
" wait_for_external_config=%(wait_for_external_config)s"
" build_images=%(build_images)s\n"
" MASTER_NODE_EXTRA_PACKAGES='%(MASTER_NODE_EXTRA_PACKAGES)s'\n"
" <Enter>\n"
) % params
return keys
def __init__(self):
self.TEMPLATE_OLD_SERIALIZATION_BOND_CONFIG = {
'mac': None,
'mode': 'active-backup',
'state': None,
'type': 'bond',
'assigned_networks': [],
'bond_properties': {
'mode': 'active-backup',
'type__': 'linux'
}
}
self.TEMPLATE_NEW_SERIALIZATION_BOND_CONFIG = {
'mac': None,
'mode': 'active-backup',
'state': None,
'type': 'bond',
'assigned_networks': [],
'attributes': {
'type__': {
'type': 'hidden',
'value': 'linux'
}
}
}
self.INTERFACES = {
'bond0': ['public', 'management', 'storage', 'private'],
'bond1': ['fuelweb_admin']
}
self.BOND_LIST = [{
'name':
'bond0',
'slaves': [{
'name': iface_alias('eth5')
}, {
'name': iface_alias('eth4')
}, {
'name': iface_alias('eth3')
}, {
'name': iface_alias('eth2')
}]
}, {
'name':
'bond1',
'slaves': [{
'name': iface_alias('eth1')
}, {
'name': iface_alias('eth0')
}]
}]
self.BOND_ATTR = {}
super(BondingTest, self).__init__()
self.__cluster_id = None
self.__bond_config = None
def get_keys(self, node, custom=None, build_images=None, iso_connect_as="cdrom"):
params = {
"device_label": settings.ISO_LABEL,
"iface": iface_alias("eth0"),
"ip": node.get_ip_address_by_network_name(self.d_env.admin_net),
"mask": self.d_env.get_network(name=self.d_env.admin_net).ip.netmask,
"gw": self.d_env.router(),
"hostname": "".join((settings.FUEL_MASTER_HOSTNAME, settings.DNS_SUFFIX)),
"nat_interface": self.d_env.nat_interface,
"nameserver": settings.DNS,
"showmenu": "yes" if settings.SHOW_FUELMENU else "no",
"wait_for_external_config": "yes",
"build_images": "1" if build_images else "0",
"MASTER_NODE_EXTRA_PACKAGES": settings.MASTER_NODE_EXTRA_PACKAGES,
}
# TODO(akostrikov) add tests for menu items/kernel parameters
# TODO(akostrikov) refactor it.
if iso_connect_as == "usb":
keys = "<Wait>\n" "<F12>\n" "2\n" # USB boot uses boot_menu=yes for master node
else: # cdrom is default
keys = "<Wait>\n" "<Wait>\n" "<Wait>\n"
keys += (
"<Esc>\n"
"<Wait>\n"
"vmlinuz initrd=initrd.img"
" inst.ks=cdrom:LABEL=%(device_label)s:/ks.cfg"
" inst.repo=cdrom:LABEL=%(device_label)s:/"
" ip=%(ip)s::%(gw)s:%(mask)s:%(hostname)s"
":%(iface)s:off::: nameserver=%(nameserver)s"
" showmenu=%(showmenu)s\n"
" wait_for_external_config=%(wait_for_external_config)s"
" build_images=%(build_images)s\n"
" MASTER_NODE_EXTRA_PACKAGES='%(MASTER_NODE_EXTRA_PACKAGES)s'\n"
" <Enter>\n"
) % params
return keys
def __init__(self):
self.BOND_CONFIG = [
{
'mac': None,
'mode': 'active-backup',
'name': 'bond0',
'slaves': [
{'name': iface_alias('eth5')},
{'name': iface_alias('eth4')},
{'name': iface_alias('eth3')},
{'name': iface_alias('eth2')}
],
'state': None,
'type': 'bond',
'assigned_networks': []
},
{
'mac': None,
'mode': 'active-backup',
'name': 'bond1',
'slaves': [
{'name': iface_alias('eth1')},
{'name': iface_alias('eth0')}
],
'state': None,
'type': 'bond',
'assigned_networks': []
}
]
self.INTERFACES = {
'bond0': [
'public',
'management',
'storage',
'private'
],
'bond1': ['fuelweb_admin']
}
super(BondingTest, self).__init__()
def ha_ceilometer_untag_network(self):
"""Deployment with 3 controllers, NeutronVLAN and untag network,
with Ceilometer
Scenario:
1. Create new environment
2. Choose Neutron, VLAN
3. Choose Ceilometer
4. Add 3 controller
5. Add 1 compute
6. Add 3 mongo+cinder
7. Move Storage network to eth1 and specify vlan start
8. Move Management network to eth2 and untag it
9. Verify networks
10. Deploy the environment
11. Verify networks
12. Run OSTF tests
Duration 180m
Snapshot ha_ceilometer_untag_network
"""
self.env.revert_snapshot("ready_with_9_slaves")
data = {
"ceilometer": True,
"tenant": "mongomultirole",
"user": "******",
"password": "******",
"net_provider": "neutron",
"net_segment_type": settings.NEUTRON_SEGMENT["vlan"],
}
self.show_step(1, initialize=True)
self.show_step(2)
self.show_step(3)
cluster_id = self.fuel_web.create_cluster(name=self.__class__.__name__, settings=data)
self.show_step(4)
self.show_step(5)
self.show_step(6)
self.fuel_web.update_nodes(
cluster_id,
{
"slave-01": ["controller"],
"slave-02": ["controller"],
"slave-03": ["controller"],
"slave-04": ["compute"],
"slave-05": ["mongo", "cinder"],
"slave-06": ["mongo", "cinder"],
"slave-07": ["mongo", "cinder"],
},
)
self.show_step(7)
self.show_step(8)
vlan_turn_on = {"vlan_start": 102}
interfaces = {
iface_alias("eth0"): ["private"],
iface_alias("eth1"): ["storage", "public"],
iface_alias("eth2"): ["management"],
iface_alias("eth3"): [],
iface_alias("eth4"): [],
}
nets = self.fuel_web.client.get_networks(cluster_id)["networks"]
nailgun_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in nailgun_nodes:
self.fuel_web.update_node_networks(node["id"], interfaces)
for net in nets:
if net["name"] == "storage":
net.update(vlan_turn_on)
self.fuel_web.client.update_network(cluster_id, networks=nets)
self.show_step(9)
self.fuel_web.verify_network(cluster_id)
self.show_step(10)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(11)
self.fuel_web.verify_network(cluster_id)
self.show_step(12)
self.fuel_web.run_ostf(cluster_id)
self.env.make_snapshot("ha_ceilometer_untag_network")
def check_bonding_with_contrail(self):
"""Verify bonding with Contrail Plugin
Scenario:
1. Revert snapshot "ready_with_5_slaves"
2. Create cluster
3. Add 3 nodes with Operating system role,
1 node with controller role and 1 node with compute role
4. Enable Contrail plugin
5. Setup bonding for management and storage interfaces
6. Deploy cluster with plugin
7. Run OSTF tests
Duration 140 min
"""
self._prepare_contrail_plugin(slaves=5)
# create cluster: 3 nodes with Operating system role,
# 1 node with controller and 1 node with compute roles
self.fuel_web.update_nodes(
self.cluster_id,
{
'slave-01': ['base-os'],
'slave-02': ['base-os'],
'slave-03': ['base-os'],
'slave-04': ['controller'],
'slave-05': ['compute']
},
custom_names={
'slave-01': 'contrail-1',
'slave-02': 'contrail-2',
'slave-03': 'contrail-3'
}
)
raw_data = [{
'mac': None,
'mode': 'active-backup',
'name': 'bond0',
'slaves': [
{'name': iface_alias('eth4')},
{'name': iface_alias('eth2')},
],
'state': None,
'type': 'bond',
'assigned_networks': []
}, ]
interfaces = {
iface_alias('eth0'): ['fuelweb_admin'],
iface_alias('eth1'): ['public'],
iface_alias('eth3'): ['private'],
'bond0': [
'management',
'storage',
]
}
cluster_nodes = \
self.fuel_web.client.list_cluster_nodes(self.cluster_id)
for node in cluster_nodes:
self.fuel_web.update_node_networks(
node['id'], interfaces_dict=interfaces,
raw_data=raw_data
)
# enable plugin in contrail settings
self._activate_plugin()
self.fuel_web.deploy_cluster_wait(self.cluster_id,
check_services=False)
# create net and subnet
self._create_net_subnet(self.cluster_id)
# TODO
# Tests using north-south connectivity are expected to fail because
# they require additional gateway nodes, and specific contrail
# settings. This mark is a workaround until it's verified
# and tested manually.
# Also workaround according to bug 1457515
# When it will be done 'should_fail=3' and
# 'failed_test_name' parameter should be removed.
self.fuel_web.run_ostf(
cluster_id=self.cluster_id,
should_fail=3,
failed_test_name=[('Check network connectivity '
'from instance via floating IP'),
'Launch instance with file injection',
'Check that required services are running']
)
def __init__(self):
super(BondingTestDPDK, self).__init__()
self.TEMPLATE_OLD_SERIALIZATION_BOND_CONFIG['interface_properties'] = {
'dpdk': {
'available': True
}
}
self.BOND_LIST = [
{
'name':
'bond0',
'slaves': [{
'name': iface_alias('eth3')
}, {
'name': iface_alias('eth2')
}],
},
{
'name':
'bond1',
'slaves': [{
'name': iface_alias('eth1')
}, {
'name': iface_alias('eth0')
}],
},
{
'name':
'bond2',
'slaves': [
{
'name': iface_alias('eth5')
},
{
'name': iface_alias('eth4')
},
],
},
]
self.INTERFACES = {
'bond0': [
'public',
'management',
'storage',
],
'bond1': ['fuelweb_admin'],
'bond2': ['private'],
}
self.BOND_ATTR = {
'dpdk': {
'enabled': {
'type': 'checkbox',
'value': False,
'weight': 10,
'label': 'DPDK enabled'
},
'metadata': {
'weight': 40,
'label': 'DPDK'
}
}
}
def jumbo_frames_neutron_vxlan(self):
"""Deploy cluster in ha mode with 3 controllers and Neutron VXLAN
Scenario:
1. Revert snapshot ready_with_5_slaves_jumbo_frames
2. Create cluster with neutron VXLAN
3. Add 3 node with controller role
4. Add 2 nodes with compute role
5. Deploy the cluster
6. Run network verification
7. Run OSTF
8. Run MTU size check
Duration 120m
Snapshot ready_jumbo_frames_neutron_vxlan
"""
self.env.revert_snapshot("ready_with_5_slaves_jumbo_frames")
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=CONF.DEPLOYMENT_MODE_HA,
settings={
"net_provider": 'neutron',
"net_segment_type": CONF.NEUTRON_SEGMENT['tun'],
}
)
interfaces = {
iface_alias('eth0'): ['fuelweb_admin'],
iface_alias('eth1'): ['public'],
iface_alias('eth2'): ['management'],
iface_alias('eth3'): ['private'],
iface_alias('eth4'): ['storage'],
}
interfaces_update = [{
'name': iface_alias('eth3'),
'interface_properties': {
'mtu': 9000,
'disable_offloading': False
},
}]
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['compute'],
}
)
slave_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in slave_nodes:
self.fuel_web.update_node_networks(
node['id'], interfaces,
override_ifaces_params=interfaces_update)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.fuel_web.verify_network(cluster_id)
self.fuel_web.run_ostf(cluster_id=cluster_id)
for node_name in ['slave-01', 'slave-02', 'slave-03',
'slave-04', 'slave-05']:
node = self.fuel_web.get_nailgun_node_by_name(node_name)
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
asserts.assert_true(
self.check_node_iface_mtu(remote,
iface_alias('eth3'),
9000),
"MTU on {0} is not 9000. Actual value: {1}"
.format(remote.host,
self.get_node_iface(remote,
iface_alias('eth3'))))
self.check_mtu_size_between_instances(mtu_offset=50)
self.env.make_snapshot("ready_jumbo_frames_neutron_vxlan")
def offloading_neutron_vlan(self):
"""Deploy cluster with specific offload modes and neutron VLAN
Scenario:
1. Create cluster with neutron VLAN
2. Add 1 node with controller role
3. Add 1 node with compute role and 1 node with cinder role
4. Setup offloading types
5. Run network verification
6. Deploy the cluster
7. Run network verification
8. Verify offloading modes on nodes
9. Run OSTF
Duration 30m
Snapshot offloading_neutron_vlan
"""
self.env.revert_snapshot("ready_with_3_slaves")
self.show_step(1)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=DEPLOYMENT_MODE,
settings={
"net_provider": 'neutron',
"net_segment_type": 'vlan',
}
)
interfaces = {
iface_alias('eth1'): ['public'],
iface_alias('eth2'): ['private'],
iface_alias('eth3'): ['management'],
iface_alias('eth4'): ['storage'],
}
offloading_modes = [{
'name': iface_alias('eth1'),
'offloading_modes': [{
'state': 'true',
'name': 'rx-vlan-offload',
'sub': []}, {
'state': 'true',
'name': 'tx-vlan-offload',
'sub': []}]}, {
'name': iface_alias('eth2'),
'offloading_modes': [{
'state': 'false',
'name': 'large-receive-offload',
'sub': []}]}]
self.show_step(2)
self.show_step(3)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
}
)
slave_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
self.show_step(4)
for node in slave_nodes:
self.fuel_web.update_node_networks(node['id'],
deepcopy(interfaces))
for offloading in offloading_modes:
self.fuel_web.update_offloads(
node['id'], deepcopy(offloading), offloading['name'])
self.show_step(5)
self.fuel_web.verify_network(cluster_id)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.fuel_web.verify_network(cluster_id)
self.show_step(8)
nodes = [self.fuel_web.get_nailgun_node_by_name(node)
for node in ['slave-01', 'slave-02', 'slave-03']]
for node in nodes:
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
logger.info("Verify Offload types")
result = check_offload(remote,
iface_alias('eth1'),
'rx-vlan-offload')
assert_equal(result, "on",
"Offload type {0} is {1} on remote host"
.format('rx-vlan-offload', result))
result = check_offload(remote,
iface_alias('eth1'),
'tx-vlan-offload')
assert_equal(result, "on",
"Offload type {0} is {1} on remote host"
.format('tx-vlan-offload', result))
result = check_offload(remote,
iface_alias('eth2'),
'large-receive-offload')
assert_equal(result, "off",
"Offload type {0} is {1} on remote host"
.format('large-receive-offload', result))
self.show_step(9)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("offloading_neutron_vlan")
def offloading_neutron_vlan(self):
"""Deploy cluster with specific offload modes and neutron VLAN
Scenario:
1. Create cluster with neutron VLAN
2. Add 1 node with controller role
3. Add 1 node with compute role and 1 node with cinder role
4. Setup offloading types
5. Run network verification
6. Deploy the cluster
7. Verify offloading modes on nodes
8. Run network verification
9. Run OSTF
Duration 30m
Snapshot offloading_neutron_vlan
"""
self.env.revert_snapshot("ready_with_3_slaves")
self.show_step(1, initialize=True)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={"net_provider": "neutron", "net_segment_type": settings.NEUTRON_SEGMENT["vlan"]},
)
self.show_step(2)
self.show_step(3)
self.fuel_web.update_nodes(
cluster_id, {"slave-01": ["controller"], "slave-02": ["compute"], "slave-03": ["cinder"]}
)
iface1 = settings.iface_alias("eth3")
iface2 = settings.iface_alias("eth2")
nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
self.show_step(4)
offloadings_1 = []
offloadings_2 = []
for node in nodes:
modes = self.fuel_web.get_offloading_modes(node["id"], [iface1])
for name in self.offloadings_1:
if name in modes and name not in offloadings_1:
offloadings_1.append(name)
modes = self.fuel_web.get_offloading_modes(node["id"], [iface2])
for name in self.offloadings_2:
if name in modes and name not in offloadings_2:
offloadings_2.append(name)
assert_true(len(offloadings_1) > 0, "No types for disable offloading")
assert_true(len(offloadings_2) > 0, "No types for enable offloading")
modes = self.prepare_offloading_modes(iface1, offloadings_1, False)
modes += self.prepare_offloading_modes(iface2, offloadings_2, True)
for node in nodes:
self.fuel_web.update_node_networks(node["id"], interfaces_dict=deepcopy(self.interfaces))
for offloading in modes:
self.fuel_web.update_offloads(node["id"], deepcopy(offloading), offloading["name"])
self.show_step(5)
self.fuel_web.verify_network(cluster_id)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.check_offloading_modes(nodes, offloadings_1, iface1, "off")
self.check_offloading_modes(nodes, offloadings_2, iface2, "on")
self.show_step(8)
self.fuel_web.verify_network(cluster_id)
self.show_step(9)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("offloading_neutron_vlan")
def offloading_neutron_vlan(self):
"""Deploy cluster with specific offload modes and neutron VLAN
Scenario:
1. Create cluster with neutron VLAN
2. Add 1 node with controller role
3. Add 1 node with compute role and 1 node with cinder role
4. Setup offloading types
5. Run network verification
6. Deploy the cluster
7. Run network verification
8. Verify offloading modes on nodes
9. Run OSTF
Duration 30m
Snapshot offloading_neutron_vlan
"""
self.env.revert_snapshot("ready_with_3_slaves")
self.show_step(1, initialize=True)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['vlan'],
}
)
self.show_step(2)
self.show_step(3)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
}
)
iface1 = settings.iface_alias('eth3')
iface2 = settings.iface_alias('eth2')
nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
self.show_step(4)
offloadings_1 = []
offloadings_2 = []
for node in nodes:
modes = self.fuel_web.get_offloading_modes(node['id'], [iface1])
for name in self.offloadings_1:
if name in modes and name not in offloadings_1:
offloadings_1.append(name)
modes = self.fuel_web.get_offloading_modes(node['id'], [iface2])
for name in self.offloadings_2:
if name in modes and name not in offloadings_2:
offloadings_2.append(name)
assert_true(len(offloadings_1) > 0, "No types for disable offloading")
assert_true(len(offloadings_2) > 0, "No types for enable offloading")
modes = self.prepare_offloading_modes(iface1, offloadings_1, False)
modes += self.prepare_offloading_modes(iface2, offloadings_2, True)
for node in nodes:
self.fuel_web.update_node_networks(
node['id'],
interfaces_dict=deepcopy(self.interfaces))
for offloading in modes:
self.fuel_web.update_offloads(
node['id'], deepcopy(offloading), offloading['name'])
self.show_step(5)
self.fuel_web.verify_network(cluster_id)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.fuel_web.verify_network(cluster_id)
self.show_step(8)
for node in nodes:
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
for name in offloadings_1:
result = check_offload(remote, iface1, name)
assert_equal(result, "off",
"Offload type {0} is {1} on {2}".format(
name, result, node['name']))
for name in offloadings_2:
result = check_offload(remote, iface2, name)
assert_equal(result, "on",
"Offload type {0} is {1} on {2}".format(
name, result, node['name']))
self.show_step(9)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("offloading_neutron_vlan")
def offloading_neutron_vlan(self):
"""Deploy cluster with specific offload modes and neutron VLAN
Scenario:
1. Create cluster with neutron VLAN
2. Add 1 node with controller role
3. Add 1 node with compute role and 1 node with cinder role
4. Setup offloading types
5. Run network verification
6. Deploy the cluster
7. Verify offloading modes on nodes
8. Run network verification
9. Run OSTF
Duration 30m
Snapshot offloading_neutron_vlan
"""
self.env.revert_snapshot("ready_with_3_slaves")
self.show_step(1, initialize=True)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['vlan'],
}
)
self.show_step(2)
self.show_step(3)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
}
)
iface1 = settings.iface_alias('eth3')
iface2 = settings.iface_alias('eth2')
nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
self.show_step(4)
offloadings_1 = {}
offloadings_2 = {}
for node in nodes:
modes = self.fuel_web.get_offloading_modes(node['id'], [iface1])
for name in self.offloadings_1:
if name in modes and name not in offloadings_1:
offloadings_1[name] = self.offloadings_1[name]
modes = self.fuel_web.get_offloading_modes(node['id'], [iface2])
for name in self.offloadings_2:
if name in modes and name not in offloadings_2:
offloadings_2[name] = self.offloadings_2[name]
assert_true(len(offloadings_1) > 0, "No types for disable offloading")
assert_true(len(offloadings_2) > 0, "No types for enable offloading")
offloadings = {
iface1: offloadings_1,
iface2: offloadings_2
}
for node in nodes:
self.fuel_web.update_node_networks(
node['id'],
interfaces_dict=deepcopy(self.interfaces))
for offloading in offloadings:
self.fuel_web.update_offloads(
node['id'], offloadings[offloading], offloading)
self.show_step(5)
self.fuel_web.verify_network(cluster_id)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.check_offloading_modes(nodes, offloadings_1, iface1, 'off')
self.check_offloading_modes(nodes, offloadings_2, iface2, 'on')
self.show_step(8)
self.fuel_web.verify_network(cluster_id)
self.show_step(9)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("offloading_neutron_vlan")
def offloading_neutron_vlan(self):
"""Deploy cluster with specific offload modes and neutron VLAN
Scenario:
1. Create cluster with neutron VLAN
2. Add 1 node with controller role
3. Add 1 node with compute role and 1 node with cinder role
4. Setup offloading types
5. Run network verification
6. Deploy the cluster
7. Run network verification
8. Verify offloading modes on nodes
9. Run OSTF
Duration 30m
Snapshot offloading_neutron_vlan
"""
self.env.revert_snapshot("ready_with_3_slaves")
self.show_step(1, initialize=True)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['vlan'],
}
)
self.show_step(2)
self.show_step(3)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
}
)
iface1 = settings.iface_alias('eth3')
iface2 = settings.iface_alias('eth2')
nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
self.show_step(4)
offloadings_1 = []
offloadings_2 = []
for node in nodes:
modes = self.fuel_web.get_offloading_modes(node['id'], [iface1])
for name in self.offloadings_1:
if name in modes and name not in offloadings_1:
offloadings_1.append(name)
modes = self.fuel_web.get_offloading_modes(node['id'], [iface2])
for name in self.offloadings_2:
if name in modes and name not in offloadings_2:
offloadings_2.append(name)
assert_true(len(offloadings_1) > 0, "No types for disable offloading")
assert_true(len(offloadings_2) > 0, "No types for enable offloading")
modes = self.prepare_offloading_modes(iface1, offloadings_1, False)
modes += self.prepare_offloading_modes(iface2, offloadings_2, True)
for node in nodes:
self.fuel_web.update_node_networks(
node['id'],
interfaces_dict=deepcopy(self.interfaces))
for offloading in modes:
self.fuel_web.update_offloads(
node['id'], deepcopy(offloading), offloading['name'])
self.show_step(5)
self.fuel_web.verify_network(cluster_id)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.fuel_web.verify_network(cluster_id)
self.show_step(8)
for node in nodes:
for name in offloadings_1:
result = check_offload(node['ip'], iface1, name)
assert_equal(result, "off",
"Offload type {0} is {1} on {2}".format(
name, result, node['name']))
for name in offloadings_2:
result = check_offload(node['ip'], iface2, name)
assert_equal(result, "on",
"Offload type {0} is {1} on {2}".format(
name, result, node['name']))
self.show_step(9)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("offloading_neutron_vlan")
def ha_ceilometer_untag_network(self):
"""Deployment with 3 controllers, NeutronVLAN and untag network,
with Ceilometer
Scenario:
1. Create new environment
2. Choose Neutron, VLAN
3. Choose Ceilometer
4. Add 3 controller
5. Add 1 compute
6. Add 3 mongo+cinder
7. Move Storage network to eth1 and specify vlan start
8. Move Management network to eth2 (it's untagged by default)
9. Verify networks
10. Deploy the environment
11. Verify networks
12. Run OSTF tests
Duration 180m
Snapshot ha_ceilometer_untag_network
"""
self.env.revert_snapshot('ready_with_9_slaves')
data = {
'ceilometer': True,
'tenant': 'mongomultirole',
'user': '******',
'password': '******',
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['vlan'],
}
self.show_step(1, initialize=True)
self.show_step(2)
self.show_step(3)
cluster_id = self.fuel_web.create_cluster(name=self.__class__.__name__,
settings=data)
self.show_step(4)
self.show_step(5)
self.show_step(6)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['mongo', 'cinder'],
'slave-06': ['mongo', 'cinder'],
'slave-07': ['mongo', 'cinder']
})
self.show_step(7)
self.show_step(8)
vlan_turn_on = {'vlan_start': 102}
interfaces = {
iface_alias('eth0'): ['private'],
iface_alias('eth1'): ['storage', 'public'],
iface_alias('eth2'): ['management'],
iface_alias('eth3'): [],
iface_alias('eth4'): []
}
nets = self.fuel_web.client.get_networks(cluster_id)['networks']
nailgun_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in nailgun_nodes:
self.fuel_web.update_node_networks(node['id'], interfaces)
[net.update(vlan_turn_on) for net in nets if net['name'] == 'storage']
self.fuel_web.client.update_network(cluster_id, networks=nets)
self.show_step(9)
self.fuel_web.verify_network(cluster_id)
self.show_step(10)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(11)
self.fuel_web.verify_network(cluster_id)
self.show_step(12)
self.fuel_web.run_ostf(cluster_id)
self.env.make_snapshot('ha_ceilometer_untag_network')
def offloading_neutron_vlan(self):
"""Deploy cluster with specific offload modes and neutron VLAN
Scenario:
1. Create cluster with neutron VLAN
2. Add 1 node with controller role
3. Add 1 node with compute role and 1 node with cinder role
4. Setup offloading types
5. Run network verification
6. Deploy the cluster
7. Run network verification
8. Verify offloading modes on nodes
9. Run OSTF
Duration 30m
Snapshot offloading_neutron_vlan
"""
self.env.revert_snapshot("ready_with_3_slaves")
self.show_step(1, initialize=True)
cluster_id = self.fuel_web.create_cluster(name=self.__class__.__name__,
mode=DEPLOYMENT_MODE,
settings={
"net_provider":
'neutron',
"net_segment_type":
'vlan',
})
interfaces = {
iface_alias('eth1'): ['public'],
iface_alias('eth2'): ['private'],
iface_alias('eth3'): ['management'],
iface_alias('eth4'): ['storage'],
}
offloading_modes = [{
'name':
iface_alias('eth1'),
'offloading_modes': [{
'state': 'true',
'name': 'rx-vlan-offload',
'sub': []
}, {
'state': 'true',
'name': 'tx-vlan-offload',
'sub': []
}]
}, {
'name':
iface_alias('eth2'),
'offloading_modes': [{
'state': 'false',
'name': 'large-receive-offload',
'sub': []
}]
}]
self.show_step(2)
self.show_step(3)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
})
slave_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
self.show_step(4)
for node in slave_nodes:
self.fuel_web.update_node_networks(node['id'],
deepcopy(interfaces))
for offloading in offloading_modes:
self.fuel_web.update_offloads(node['id'], deepcopy(offloading),
offloading['name'])
self.show_step(5)
self.fuel_web.verify_network(cluster_id)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.fuel_web.verify_network(cluster_id)
self.show_step(8)
nodes = [
self.fuel_web.get_nailgun_node_by_name(node)
for node in ['slave-01', 'slave-02', 'slave-03']
]
for node in nodes:
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
logger.info("Verify Offload types")
result = check_offload(remote, iface_alias('eth1'),
'rx-vlan-offload')
assert_equal(
result, "on",
"Offload type {0} is {1} on remote host".format(
'rx-vlan-offload', result))
result = check_offload(remote, iface_alias('eth1'),
'tx-vlan-offload')
assert_equal(
result, "on",
"Offload type {0} is {1} on remote host".format(
'tx-vlan-offload', result))
result = check_offload(remote, iface_alias('eth2'),
'large-receive-offload')
assert_equal(
result, "off",
"Offload type {0} is {1} on remote host".format(
'large-receive-offload', result))
self.show_step(9)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("offloading_neutron_vlan")
class TestOffloading(TestBasic):
interfaces = {
settings.iface_alias('eth1'): ['public'],
settings.iface_alias('eth2'): ['management'],
settings.iface_alias('eth3'): ['private'],
settings.iface_alias('eth4'): ['storage'],
}
offloadings_1 = ['generic-receive-offload',
'generic-segmentation-offload',
'tcp-segmentation-offload',
'large-receive-offload']
offloadings_2 = ['rx-all',
'rx-vlan-offload',
'tx-vlan-offload']
def prepare_offloading_modes(self, interface, types, state):
return [{'name': interface,
'offloading_modes': [{'name': name, 'state': state,
'sub': []} for name in types]}]
@test(depends_on=[SetupEnvironment.prepare_slaves_3],
groups=["offloading_neutron_vlan", "offloading"])
@log_snapshot_after_test
def offloading_neutron_vlan(self):
"""Deploy cluster with specific offload modes and neutron VLAN
Scenario:
1. Create cluster with neutron VLAN
2. Add 1 node with controller role
3. Add 1 node with compute role and 1 node with cinder role
4. Setup offloading types
5. Run network verification
6. Deploy the cluster
7. Run network verification
8. Verify offloading modes on nodes
9. Run OSTF
Duration 30m
Snapshot offloading_neutron_vlan
"""
self.env.revert_snapshot("ready_with_3_slaves")
self.show_step(1, initialize=True)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['vlan'],
}
)
self.show_step(2)
self.show_step(3)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
}
)
iface1 = settings.iface_alias('eth3')
iface2 = settings.iface_alias('eth2')
nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
self.show_step(4)
offloadings_1 = []
offloadings_2 = []
for node in nodes:
modes = self.fuel_web.get_offloading_modes(node['id'], [iface1])
for name in self.offloadings_1:
if name in modes and name not in offloadings_1:
offloadings_1.append(name)
modes = self.fuel_web.get_offloading_modes(node['id'], [iface2])
for name in self.offloadings_2:
if name in modes and name not in offloadings_2:
offloadings_2.append(name)
assert_true(len(offloadings_1) > 0, "No types for disable offloading")
assert_true(len(offloadings_2) > 0, "No types for enable offloading")
modes = self.prepare_offloading_modes(iface1, offloadings_1, False)
modes += self.prepare_offloading_modes(iface2, offloadings_2, True)
for node in nodes:
self.fuel_web.update_node_networks(
node['id'],
interfaces_dict=deepcopy(self.interfaces))
for offloading in modes:
self.fuel_web.update_offloads(
node['id'], deepcopy(offloading), offloading['name'])
self.show_step(5)
self.fuel_web.verify_network(cluster_id)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.fuel_web.verify_network(cluster_id)
self.show_step(8)
for node in nodes:
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
for name in offloadings_1:
result = check_offload(remote, iface1, name)
assert_equal(result, "off",
"Offload type {0} is {1} on {2}".format(
name, result, node['name']))
for name in offloadings_2:
result = check_offload(remote, iface2, name)
assert_equal(result, "on",
"Offload type {0} is {1} on {2}".format(
name, result, node['name']))
self.show_step(9)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("offloading_neutron_vlan")
@test(depends_on=[SetupEnvironment.prepare_slaves_3],
groups=["offloading_neutron_vxlan", "offloading"])
@log_snapshot_after_test
def offloading_neutron_vxlan(self):
"""Deploy cluster with specific offload modes and neutron VXLAN
Scenario:
1. Create cluster with neutron VXLAN
2. Add 1 node with controller role
3. Add 1 node with compute role and 1 node with cinder role
4. Setup offloading types
5. Run network verification
6. Deploy the cluster
7. Run network verification
8. Verify offloading modes on nodes
9. Run OSTF
Duration 30m
Snapshot offloading_neutron_vxlan
"""
self.env.revert_snapshot("ready_with_3_slaves")
self.show_step(1, initialize=True)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE,
settings={
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['vlan'],
}
)
self.show_step(2)
self.show_step(3)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['compute'],
'slave-03': ['cinder']
}
)
iface1 = settings.iface_alias('eth3')
iface2 = settings.iface_alias('eth2')
nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
self.show_step(4)
offloadings_1 = []
offloadings_2 = []
for node in nodes:
modes = self.fuel_web.get_offloading_modes(node['id'], [iface1])
for name in self.offloadings_1:
if name in modes and name not in offloadings_1:
offloadings_1.append(name)
modes = self.fuel_web.get_offloading_modes(node['id'], [iface2])
for name in self.offloadings_2:
if name in modes and name not in offloadings_2:
offloadings_2.append(name)
assert_true(len(offloadings_1) > 0, "No types for disable offloading")
assert_true(len(offloadings_2) > 0, "No types for enable offloading")
modes = self.prepare_offloading_modes(iface1, offloadings_1, False)
modes += self.prepare_offloading_modes(iface2, offloadings_2, True)
for node in nodes:
self.fuel_web.update_node_networks(
node['id'],
interfaces_dict=deepcopy(self.interfaces))
for offloading in modes:
self.fuel_web.update_offloads(
node['id'], deepcopy(offloading), offloading['name'])
self.show_step(5)
self.fuel_web.verify_network(cluster_id)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.fuel_web.verify_network(cluster_id)
self.show_step(8)
for node in nodes:
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
for name in offloadings_1:
result = check_offload(remote, iface1, name)
assert_equal(result, "off",
"Offload type {0} is {1} on {2}".format(
name, result, node['name']))
for name in offloadings_2:
result = check_offload(remote, iface2, name)
assert_equal(result, "on",
"Offload type {0} is {1} on {2}".format(
name, result, node['name']))
self.show_step(9)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("offloading_neutron_vxlan")
class TestJumboFrames(base_test_case.TestBasic):
def __init__(self):
self.os_conn = None
super(TestJumboFrames, self).__init__()
interfaces = {
iface_alias('eth0'): ['fuelweb_admin'],
iface_alias('eth1'): ['public'],
iface_alias('eth2'): ['management'],
iface_alias('eth3'): ['private'],
iface_alias('eth4'): ['storage'],
}
interfaces_update = [{
'name': iface_alias('eth3'),
'interface_properties': {
'mtu': 9000,
'disable_offloading': False
},
}]
def check_node_iface_mtu(self, node, iface, mtu):
"""Check mtu on environment node network interface."""
return "mtu {0}".format(mtu) in self.get_node_iface(node, iface)
@staticmethod
def get_node_iface(node, iface):
"""Get environment node network interface."""
command = "sudo ip link show {0}".format(iface)
return ''.join(node.execute(command)['stdout'])
@staticmethod
def set_host_iface_mtu(iface, mtu):
"""Set devops/fuel-qa host network interface mtu."""
command = "sudo ip link set {0} mtu {1}".format(iface, mtu).split()
return subprocess.call(command, stderr=subprocess.STDOUT)
@staticmethod
def get_host_iface(iface):
"""Get devops/fuel-qa host network interface."""
command = "sudo ip link show {0}".format(iface).split()
return subprocess.check_output(command, stderr=subprocess.STDOUT)
@staticmethod
def get_host_bridge_ifaces(bridge_name):
"""Get list of devops/fuel-qa host network bridge interfaces."""
command = "sudo brctl show {0}".format(bridge_name).split()
ifaces = subprocess.check_output(command, stderr=subprocess.STDOUT)
ifaces = ifaces.splitlines()[1:]
bridge_iface = ifaces[0].split()[-1]
ifaces = [iface.strip() for iface in ifaces[1:]]
ifaces.append(bridge_iface)
return ifaces
def boot_instance_on_node(self,
hypervisor_name,
label,
boot_timeout=300,
need_floating_ip=True):
instance = self.os_conn.create_server_for_migration(
neutron=True,
availability_zone="nova:{0}".format(hypervisor_name),
label=label)
logger.info("New instance {0} created on {1}".format(
instance.id, hypervisor_name))
ip = self.os_conn.get_nova_instance_ip(instance,
net_name=label,
addrtype='fixed')
logger.info("Instance {0} has IP {1}".format(instance.id, ip))
if not need_floating_ip:
return self.os_conn.nova.servers.get(instance.id)
ip = self.os_conn.assign_floating_ip(instance)
logger.info("Floating address {0} associated with instance {1}".format(
ip.ip, instance.id))
logger.info("Wait for ping from instance {}".format(instance.id))
devops_helpers.wait(
lambda: devops_helpers.tcp_ping(ip.ip, 22),
timeout=boot_timeout,
timeout_msg=("Instance {0} is unreachable for {1} seconds".format(
instance.id, boot_timeout)))
return self.os_conn.nova.servers.get(instance.id)
def ping_instance_from_instance(self,
source_instance,
destination_instance,
net_from,
net_to,
size,
count=1):
creds = ("cirros", "cubswin:)")
destination_ip = self.os_conn.get_nova_instance_ip(
destination_instance, net_name=net_to, addrtype='fixed')
source_ip = self.os_conn.get_nova_instance_ip(source_instance,
net_name=net_from,
addrtype='floating')
with self.fuel_web.get_ssh_for_node("slave-01") as ssh:
command = "ping -s {0} {1}".format(size, destination_ip)
if count:
command = "{0} -c {1}".format(command, count)
logger.info(
"Try to ping private address {0} from {1} with {2} {3} bytes "
"packet(s): {4}".format(destination_ip, source_ip, count, size,
command))
ping = self.os_conn.execute_through_host(ssh, source_ip, command,
creds)
logger.info("Ping result: \n"
"{0}\n"
"{1}\n"
"exit_code={2}".format(ping['stdout'], ping['stderr'],
ping['exit_code']))
return 0 == ping['exit_code']
def check_mtu_size_between_instances(self, mtu_offset, diff_net=False):
"""Check private network mtu size
Scenario:
1. Boot two instances on different compute hosts
2. Ping one from another with 1472 bytes package
3. Ping one from another with 8972 bytes package
4. Ping one from another with 8973 bytes package
5. Ping one from another with 14472 bytes package
6. Delete instances
"""
cluster_id = self.fuel_web.get_last_created_cluster()
self.os_conn = os_actions.OpenStackActions(
self.fuel_web.get_public_vip(cluster_id))
net_name = self.fuel_web.get_cluster_predefined_networks_name(
cluster_id)['private_net']
net_destination = net_name
need_floating_ip = True
hypervisors = self.os_conn.get_hypervisors()
if diff_net:
net_destination = 'private1'
need_floating_ip = False
net1 = self.os_conn.create_network(net_destination)['network']
subnet1 = self.os_conn.create_subnet('private1_subnet', net1['id'],
'192.168.200.0/24')
router = self.os_conn.get_router_by_name('router04')
self.os_conn.add_router_interface(router['id'], subnet1['id'])
destination_instance = self.boot_instance_on_node(
hypervisors[1].hypervisor_hostname,
label=net_destination,
need_floating_ip=need_floating_ip)
source_instance = self.boot_instance_on_node(
hypervisors[0].hypervisor_hostname, label=net_name)
logger.info(
"Wait for ping from instance {}".format(destination_instance))
devops_helpers.wait(
lambda: self.ping_instance_from_instance(source_instance,
destination_instance,
net_name,
net_destination,
size=15,
count=3),
interval=10,
timeout=600,
timeout_msg=("Instance {0} is unreachable for 600 seconds".format(
destination_instance.id)))
for mtu in [1500, 9000, 9001]:
size = mtu - 28 - mtu_offset
if mtu <= 9000:
asserts.assert_true(
self.ping_instance_from_instance(source_instance,
destination_instance,
net_name,
net_destination,
size=size,
count=3),
"Ping response was not received for "
"{} bytes package".format(mtu))
else:
asserts.assert_false(
self.ping_instance_from_instance(source_instance,
destination_instance,
net_name,
net_destination,
size=size,
count=3),
"Ping response was not received for "
"{} bytes package".format(mtu))
for instance in [source_instance, destination_instance]:
self.os_conn.delete_instance(instance)
self.os_conn.verify_srv_deleted(instance)
@test(depends_on=[base_test_case.SetupEnvironment.prepare_slaves_5],
groups=["prepare_5_slaves_with_jumbo_frames"])
def prepare_5_slaves_with_jumbo_frames(self):
"""Setup jumbo frames on private bridge on host
Scenario:
1. Find bridge with name "private"
2. Set mtu 9000 for all bridge interfaces
3. Make snapshot ready_with_5_slaves_jumbo_frames
Duration 5m
Snapshot ready_with_5_slaves_jumbo_frames
"""
self.check_run("ready_with_5_slaves_jumbo_frames")
self.env.revert_snapshot("ready_with_5_slaves")
devops_env = self.env.d_env
private_bridge = devops_env.get_network(name='private').bridge_name()
logger.info(
"Search for {0} interfaces for update".format(private_bridge))
bridge_interfaces = self.get_host_bridge_ifaces(private_bridge)
logger.info("Found {0} interfaces for update: {1}".format(
len(bridge_interfaces), bridge_interfaces))
for iface in bridge_interfaces:
self.set_host_iface_mtu(iface, 9000)
logger.info("MTU of {0} was changed to 9000".format(iface))
logger.debug("New {0} interface properties:\n{1}".format(
iface, self.get_host_iface(iface)))
self.env.make_snapshot("ready_with_5_slaves_jumbo_frames",
is_make=True)
@test(depends_on=[prepare_5_slaves_with_jumbo_frames],
groups=["jumbo_frames_neutron_vlan"])
@decorators.log_snapshot_after_test
def jumbo_frames_neutron_vlan(self):
"""Verify jumbo frames between instances on HA Neutron VLAN
Scenario:
1. Revert snapshot ready_with_5_slaves_jumbo_frames
2. Create cluster with neutron VLAN
3. Add 3 node with controller role
4. Add 2 nodes with compute role
5. Set mtu=9000 on private interface
6. Deploy the cluster
7. Run network verification
8. Check MTU on private interface
9. Run MTU size check
10. Run OSTF
Duration 120m
Snapshot ready_jumbo_frames_neutron_vlan
"""
self.show_step(1, initialize=True)
self.env.revert_snapshot("ready_with_5_slaves_jumbo_frames")
self.show_step(2)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings={
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['vlan'],
})
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['compute'],
})
self.show_step(5)
slave_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in slave_nodes:
self.fuel_web.update_node_networks(
node['id'],
self.interfaces,
override_ifaces_params=self.interfaces_update)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.fuel_web.verify_network(cluster_id)
self.show_step(8)
for node_name in [
'slave-01', 'slave-02', 'slave-03', 'slave-04', 'slave-05'
]:
node = self.fuel_web.get_nailgun_node_by_name(node_name)
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
for iface in self.interfaces_update:
asserts.assert_true(
self.check_node_iface_mtu(remote, iface['name'], 9000),
"MTU on {0} is not 9000. "
"Actual value: {1}".format(
remote.host,
self.get_node_iface(remote, iface['name'])))
self.show_step(9)
self.check_mtu_size_between_instances(mtu_offset=0)
self.show_step(10)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("ready_jumbo_frames_neutron_vlan")
@test(depends_on=[prepare_5_slaves_with_jumbo_frames],
groups=["jumbo_frames_neutron_vxlan"])
@decorators.log_snapshot_after_test
def jumbo_frames_neutron_vxlan(self):
"""Verify jumbo frames between instances on HA and Neutron VXLAN
Scenario:
1. Revert snapshot ready_with_5_slaves_jumbo_frames
2. Create cluster with neutron VXLAN
3. Add 3 node with controller role
4. Add 2 nodes with compute role
5. Set mtu=9000 on private interface
6. Deploy the cluster
7. Run network verification
8. Check MTU on private interface
9. Run MTU size check
10. Run OSTF
Duration 120m
Snapshot ready_jumbo_frames_neutron_vxlan
"""
self.show_step(1, initialize=True)
self.env.revert_snapshot("ready_with_5_slaves_jumbo_frames")
self.show_step(2)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings={
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['tun'],
})
self.show_step(3)
self.show_step(4)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['compute'],
})
self.show_step(5)
slave_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in slave_nodes:
self.fuel_web.update_node_networks(
node['id'],
self.interfaces,
override_ifaces_params=self.interfaces_update)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.fuel_web.verify_network(cluster_id)
self.show_step(8)
for node_name in [
'slave-01', 'slave-02', 'slave-03', 'slave-04', 'slave-05'
]:
node = self.fuel_web.get_nailgun_node_by_name(node_name)
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
for iface in self.interfaces_update:
asserts.assert_true(
self.check_node_iface_mtu(remote, iface['name'], 9000),
"MTU on {0} is not 9000. "
"Actual value: {1}".format(
remote.host,
self.get_node_iface(remote, iface['name'])))
self.show_step(9)
self.check_mtu_size_between_instances(mtu_offset=50)
self.show_step(10)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("ready_jumbo_frames_neutron_vxlan")
@test(depends_on=[prepare_5_slaves_with_jumbo_frames],
groups=["jumbo_frames_neutron_diff_net_vlan"])
@decorators.log_snapshot_after_test
def jumbo_frames_neutron_diff_net_vlan(self):
"""Verify jumbo frames between instances in different networks on HA
and Neutron VLAN
Scenario:
1. Revert snapshot ready_with_5_slaves_jumbo_frames
2. Create cluster with neutron VLAN
3. Add 3 node with controller role
4. Add 2 nodes with compute role
5. Set mtu=9000 on private interface
6. Deploy the cluster
7. Run network verification
8. Check MTU on private interface
9. Run MTU size check
10. Run OSTF
Duration 120m
Snapshot jumbo_frames_neutron_diff_bond_vlan
"""
self.show_step(1, initialize=True)
self.env.revert_snapshot("ready_with_5_slaves_jumbo_frames")
self.show_step(2)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings={
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['vlan'],
})
self.show_step(3)
self.show_step(4)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['compute'],
})
self.show_step(5)
slave_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in slave_nodes:
self.fuel_web.update_node_networks(
node['id'],
interfaces_dict=deepcopy(self.interfaces),
override_ifaces_params=self.interfaces_update)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.fuel_web.verify_network(cluster_id)
self.show_step(8)
for node_name in [
'slave-01', 'slave-02', 'slave-03', 'slave-04', 'slave-05'
]:
node = self.fuel_web.get_nailgun_node_by_name(node_name)
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
for iface in self.interfaces_update:
asserts.assert_true(
self.check_node_iface_mtu(remote, iface['name'], 9000),
"MTU on {0} is not 9000. "
"Actual value: {1}".format(
remote.host,
self.get_node_iface(remote, iface['name'])))
self.show_step(9)
self.check_mtu_size_between_instances(mtu_offset=0, diff_net=True)
self.show_step(10)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("jumbo_frames_neutron_diff_net_vlan")
@test(depends_on=[prepare_5_slaves_with_jumbo_frames],
groups=["jumbo_frames_neutron_diff_net_vxlan"])
@decorators.log_snapshot_after_test
def jumbo_frames_neutron_diff_net_vxlan(self):
"""Verify jumbo frames between instances in different networks on HA
and Neutron VXLAN
Scenario:
1. Revert snapshot ready_with_5_slaves_jumbo_frames
2. Create cluster with neutron VXLAN
3. Add 3 node with controller role
4. Add 2 nodes with compute role
5. Set mtu=9000 on private interface
6. Deploy the cluster
7. Run network verification
8. Check MTU on private interface
9. Run MTU size check
10. Run OSTF
Duration 120m
Snapshot jumbo_frames_neutron_diff_bond_vxlan
"""
self.show_step(1, initialize=True)
self.env.revert_snapshot("ready_with_5_slaves_jumbo_frames")
self.show_step(2)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
mode=settings.DEPLOYMENT_MODE_HA,
settings={
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['tun'],
})
self.show_step(3)
self.show_step(4)
self.fuel_web.update_nodes(
cluster_id, {
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['compute'],
})
self.show_step(5)
slave_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in slave_nodes:
self.fuel_web.update_node_networks(
node['id'],
interfaces_dict=deepcopy(self.interfaces),
override_ifaces_params=self.interfaces_update)
self.show_step(6)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(7)
self.fuel_web.verify_network(cluster_id)
self.show_step(8)
for node_name in [
'slave-01', 'slave-02', 'slave-03', 'slave-04', 'slave-05'
]:
node = self.fuel_web.get_nailgun_node_by_name(node_name)
with self.env.d_env.get_ssh_to_remote(node['ip']) as remote:
for iface in self.interfaces_update:
asserts.assert_true(
self.check_node_iface_mtu(remote, iface['name'], 9000),
"MTU on {0} is not 9000. "
"Actual value: {1}".format(
remote.host,
self.get_node_iface(remote, iface['name'])))
self.show_step(9)
self.check_mtu_size_between_instances(mtu_offset=50, diff_net=True)
self.show_step(10)
self.fuel_web.run_ostf(cluster_id=cluster_id)
self.env.make_snapshot("jumbo_frames_neutron_diff_net_vxlan")
METADATA_IP = os.environ.get('METADATA_IP', '169.254.169.254')
VM_USER = '******'
VM_PASS = '******'
AZ_VCENTER1 = 'vcenter'
AZ_VCENTER2 = 'vcenter2'
FLAVOR_NAME = 'm1.micro128'
PLUGIN_NAME = os.environ.get('PLUGIN_NAME', 'nsx-t')
NSXT_PLUGIN_PATH = os.environ.get('NSXT_PLUGIN_PATH')
NSXT_PLUGIN_VERSION = os.environ.get('NSXT_PLUGIN_VERSION', '1.0.0')
NSXT_MANAGERS_IP = os.environ.get('NSXT_MANAGERS_IP')
NSXT_USER = os.environ.get('NSXT_USER')
assigned_networks = {
iface_alias('eth0'): ['fuelweb_admin', 'private'],
iface_alias('eth1'): ['public'],
iface_alias('eth2'): ['management'],
iface_alias('eth4'): ['storage']
}
cluster_settings = {
'net_provider': 'neutron',
'assign_to_all_nodes': True,
'net_segment_type': NEUTRON_SEGMENT_TYPE
}
plugin_configuration = {
'insecure/value': get_var_as_bool(os.environ.get('NSXT_INSECURE'), True),
'nsx_api_managers/value': NSXT_MANAGERS_IP,
'nsx_api_user/value': NSXT_USER,
def ha_ceilometer_untag_network(self):
"""Deployment with 3 controllers, NeutronVLAN and untag network,
with Ceilometer
Scenario:
1. Create new environment
2. Choose Neutron, VLAN
3. Choose Ceilometer
4. Add 3 controller
5. Add 1 compute
6. Add 3 mongo+cinder
7. Move Storage network to eth1 and specify vlan start
8. Move Management network to eth2 and untag it
9. Verify networks
10. Deploy the environment
11. Verify networks
12. Run OSTF tests
Duration 180m
Snapshot ha_ceilometer_untag_network
"""
self.env.revert_snapshot('ready_with_9_slaves')
data = {
'ceilometer': True,
'tenant': 'mongomultirole',
'user': '******',
'password': '******',
"net_provider": 'neutron',
"net_segment_type": settings.NEUTRON_SEGMENT['vlan'],
}
self.show_step(1, initialize=True)
self.show_step(2)
self.show_step(3)
cluster_id = self.fuel_web.create_cluster(
name=self.__class__.__name__,
settings=data
)
self.show_step(4)
self.show_step(5)
self.show_step(6)
self.fuel_web.update_nodes(
cluster_id,
{
'slave-01': ['controller'],
'slave-02': ['controller'],
'slave-03': ['controller'],
'slave-04': ['compute'],
'slave-05': ['mongo', 'cinder'],
'slave-06': ['mongo', 'cinder'],
'slave-07': ['mongo', 'cinder']
}
)
self.show_step(7)
self.show_step(8)
vlan_turn_on = {'vlan_start': 102}
interfaces = {
iface_alias('eth0'): ['private'],
iface_alias('eth1'): ['storage', 'public'],
iface_alias('eth2'): ['management'],
iface_alias('eth3'): [],
iface_alias('eth4'): []
}
nets = self.fuel_web.client.get_networks(cluster_id)['networks']
nailgun_nodes = self.fuel_web.client.list_cluster_nodes(cluster_id)
for node in nailgun_nodes:
self.fuel_web.update_node_networks(node['id'], interfaces)
for net in nets:
if net['name'] == 'storage':
net.update(vlan_turn_on)
self.fuel_web.client.update_network(cluster_id, networks=nets)
self.show_step(9)
self.fuel_web.verify_network(cluster_id)
self.show_step(10)
self.fuel_web.deploy_cluster_wait(cluster_id)
self.show_step(11)
self.fuel_web.verify_network(cluster_id)
self.show_step(12)
self.fuel_web.run_ostf(cluster_id)
self.env.make_snapshot('ha_ceilometer_untag_network')
