x
/
tobiko
Code Issues Proposed changes

[WIP] Fix unsupported container names on OSP 13 

Change-Id: I8fe71d78c0f4987d71a966e4f1570f234e7a1109
This commit is contained in:
Federico Ressi 2021-08-02 22:27:27 +02:00
parent a4015d479b
commit 0922e3bc61
4 changed files with 204 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
tobiko/tests/functional/tripleo/test_containers.py
View File

@ -16,6 +16,7 @@ from __future__ import absolute_import
import testtools
from tobiko.tripleo import containers
from tobiko.tripleo import topology
@containers.skip_unless_has_container_runtime()
@ -29,3 +30,16 @@ class RuntimeRuntimeTest(testtools.TestCase):
containers_list = containers.list_containers()
for container in containers_list:
self.assertIsNotNone(container)
@topology.skip_unless_has_tripleo_version(min_version=16)
class AssertTripleORunningContainersTest(testtools.TestCase):
def test_assert_controller_containers_running(self):
containers.assert_controller_containers_running()
def test_assert_compute_containers_running(self):
containers.assert_compute_containers_running()
def test_assert_ovn_containers_running(self):
containers.assert_ovn_containers_running()

21
tobiko/tripleo/_topology.py
View File

@ -18,6 +18,7 @@ import typing # noqa
from oslo_log import log
import tobiko
from tobiko.openstack import neutron
from tobiko.openstack import nova
from tobiko.openstack import topology
@ -25,6 +26,7 @@ from tobiko.shell import files
from tobiko.shell import sh
from tobiko.tripleo import _overcloud
from tobiko.tripleo import _undercloud
from tobiko.tripleo import _version
LOG = log.getLogger(__name__)
@ -159,6 +161,16 @@ class TripleoTopologyNode(topology.OpenStackTopologyNode):
_overcloud.power_off_overcloud_node(server)
LOG.debug(f"Overcloud server node {self.name} power is off.")
_tripleo_version: _version.TripleoVersion
@property
def tripleo_version(self) -> _version.TripleoVersion:
try:
return self._tripleo_version
except AttributeError:
self._tripleo_version = _version.get_tripleo_version(
ssh_client=self.ssh_client)
def is_valid_overcloud_group_name(group_name: str, node_name: str = None):
if not group_name:
@ -218,3 +230,12 @@ def is_composable_roles_env():
if nodes in topology.list_openstack_node_groups():
return True
return False
def get_tripleo_node_version(node: TripleoTopologyNode = None,
group: str = None):
if node is None:
if group is None:
group = 'overcloud'
node = topology.list_openstack_nodes(group=group).first
return node.tripleo_version

129
tobiko/tripleo/_version.py Normal file
View File

@ -0,0 +1,129 @@
# Copyright 2021 Red Hat
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from __future__ import absolute_import
import re
import typing
import tobiko
from tobiko.openstack import topology
from tobiko.shell import sh
from tobiko.shell import ssh
class TripleoVersion(typing.NamedTuple):
major: int
minor: int = 0
micro: int = 0
product_name: typing.Optional[str] = None
def get_tripleo_version(ssh_client: ssh.SSHClientType = None,
group: str = None) \
-> TripleoVersion:
if ssh_client is None:
if group is None:
group = 'overcloud'
for node in topology.list_openstack_nodes(group=group):
ssh_client = node.ssh_client
break
else:
raise TripleoVersionError(error=f"No such nodes for group '{group}'")
assert ssh_client is not None
try:
release_string = sh.execute('cat /etc/rhosp-release',
ssh_client=ssh_client).stdout.strip()
except sh.ShellCommandFailed as ex:
raise TripleoVersionError(error=ex.stderr) from ex
return parse_tripleo_release(release_string)
RELEASE_PATTERN = re.compile(r' release ')
VERSION_PATTERN = re.compile(r'([\d]+)(\.[\d]+)?(\.[\d]+)?')
def parse_tripleo_release(release_string: str,
product_name: str = None):
if product_name is None:
# Example of release_string:
# 'Red Hat OpenStack Platform release 13.0.16 (Queens)'
match = RELEASE_PATTERN.search(release_string)
if match is not None:
product_name = release_string[:match.start()]
release_string = release_string[match.end():]
return parse_tripleo_version(version_string=release_string.strip(),
product_name=product_name)
def parse_tripleo_version(version_string: str,
product_name: str = None):
# Example of version_string:
# '13.0.16 (Queens)'
match = VERSION_PATTERN.search(version_string)
if match is None:
raise TripleoVersionError(f'Invalid version string: {version_string}')
version = [int(n)
for n in version_string[match.start():match.end()].split('.')[:3]]
return TripleoVersion(*version,
product_name=product_name)
TripleoVersionType = typing.Union[TripleoVersion, float, int, str]
def check_tripleo_version(min_version: TripleoVersionType = None,
max_version: TripleoVersionType = None,
ssh_client: ssh.SSHClientType = None,
group: str = None) \
-> None:
version = get_tripleo_version(ssh_client=ssh_client, group=group)
if min_version is not None:
min_version = tripleo_version(min_version)
if min_version > version:
raise TripleoVersionError(f"TripleO version '{version}' is "
f"smaller than '{min_version}'")
if max_version is not None:
max_version = tripleo_version(max_version)
if max_version < min_version:
raise TripleoVersionError(f"TripleO version '{version}' is "
f"greater than '{max_version}'")
def skip_unless_has_tripleo_version(min_version: TripleoVersionType = None,
max_version: TripleoVersionType = None,
ssh_client: ssh.SSHClientType = None,
group: str = None):
return tobiko.skip_if_raises(TripleoVersionError,
check_tripleo_version,
min_version=min_version,
max_version=max_version,
group=group)
TripleoVersionType = typing.Union[TripleoVersion, str, float, int]
def tripleo_version(obj: TripleoVersionType,
product_name: str = None) \
-> TripleoVersion:
if isinstance(obj, TripleoVersion):
return obj
if isinstance(obj, (float, int, str)):
return parse_tripleo_version(version_string=str(obj),
product_name=product_name)
raise TypeError(f"Can't get TripleO version from {obj!r}")
class TripleoVersionError(tobiko.TobikoException):
message = "{error}"

75
tobiko/tripleo/containers.py
View File

@ -258,47 +258,52 @@ def assert_all_tripleo_containers_running():
param: group controller or compute , check containers
sets in computes or controllers"""
common_controller_tripleo_containers = ['cinder_api', 'cinder_api_cron',
'cinder_scheduler',
'glance_api', 'heat_api',
'heat_api_cfn',
'heat_api_cron', 'heat_engine',
'horizon', 'iscsid', 'keystone',
'logrotate_crond', 'memcached',
'neutron_api', 'nova_api',
'nova_api_cron', 'nova_conductor',
'nova_metadata', 'nova_scheduler',
'nova_vnc_proxy',
'swift_account_auditor',
'swift_account_reaper',
'swift_account_replicator',
'swift_account_server',
'swift_container_auditor',
'swift_container_replicator',
'swift_container_server',
'swift_container_updater',
'swift_object_auditor',
'swift_object_expirer',
'swift_object_replicator',
'swift_object_server',
'swift_object_updater',
'swift_proxy', 'swift_rsync']
assert_controller_containers_running()
assert_compute_containers_running()
common_compute_tripleo_containers = ['iscsid', 'logrotate_crond',
'nova_compute', 'nova_libvirt',
'nova_migration_target',
'nova_virtlogd']
for group, group_containers in [('controller',
common_controller_tripleo_containers),
('compute',
common_compute_tripleo_containers)]:
assert_containers_running(group, group_containers)
# TODO: need to address OSP-version specific containers here.
# optional ovn containers checks
assert_ovn_containers_running()
def assert_controller_containers_running():
assert_containers_running('controller',
['cinder_api', 'cinder_api_cron',
'cinder_scheduler',
'glance_api', 'heat_api',
'heat_api_cfn',
'heat_api_cron', 'heat_engine',
'horizon', 'iscsid', 'keystone',
'logrotate_crond', 'memcached',
'neutron_api', 'nova_api',
'nova_api_cron', 'nova_conductor',
'nova_metadata', 'nova_scheduler',
'nova_vnc_proxy',
'swift_account_auditor',
'swift_account_reaper',
'swift_account_replicator',
'swift_account_server',
'swift_container_auditor',
'swift_container_replicator',
'swift_container_server',
'swift_container_updater',
'swift_object_auditor',
'swift_object_expirer',
'swift_object_replicator',
'swift_object_server',
'swift_object_updater',
'swift_proxy', 'swift_rsync'])
def assert_compute_containers_running():
assert_containers_running('compute', ['iscsid',
'logrotate_crond',
'nova_compute',
'nova_libvirt',
'nova_migration_target',
'nova_virtlogd'])
def assert_ovn_containers_running():
# specific OVN verifications
if neutron.has_ovn():