starlingx/distcloud
Code Issues Proposed changes

Remove client cache in audit worker manager

Browse Source 
This commit removes the client cache used with OpenStackDriver in the
subcloud's audit worker manager in order to remove the connection
persistence, deleting all of them once the audit process finishes.

The resulting improvements, considering 5K subclouds, were:
- Time taken to complete the audit process with a subcloud with full
  audit: from 5 seconds to 1 second
- Time taken to create the client: from ~1 seconds when there wasn't an
  available cache and ~500ms when there was to ~400ms

Test plan:
1. PASS: Execute a complete audit process in a DC system with over
4K subclouds
2. PASS: Verify that all of the keystone connections are closed
once the audit process is finished
3. PASS: Verify that the number of connections created during
audit is equal to or less than the number of subclouds to audit.

Story: 2011106
Task: 50224

Change-Id: I02597786977b2916fb9dc3fc9e70492670345636
Signed-off-by: Raphael Lima <Raphael.Lima@windriver.com>
This commit is contained in:
Raphael Lima
2024-05-23 13:09:04 -03:00
parent a90c7cfd06
commit 7181b6e476
12 changed files with 455 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
distributedcloud/dcmanager/audit/firmware_audit.py
View File

@@ -15,7 +15,6 @@
# limitations under the License.
#
from keystoneauth1 import exceptions as keystone_exceptions
from oslo_log import log as logging
from dccommon import consts as dccommon_consts
@@ -236,8 +235,11 @@ class FirmwareAudit(object):
return False
return True
def subcloud_firmware_audit(self, subcloud_name, subcloud_region, audit_data):
def subcloud_firmware_audit(
self, sysinv_client, subcloud_name, subcloud_region, audit_data
):
LOG.info('Triggered firmware audit for: %s.' % subcloud_name)
if not audit_data:
self._update_subcloud_sync_status(
subcloud_name,
@@ -245,22 +247,6 @@ class FirmwareAudit(object):
dccommon_consts.SYNC_STATUS_IN_SYNC)
LOG.debug('No images to audit, exiting firmware audit')
return
try:
sc_os_client = OpenStackDriver(
region_name=subcloud_region,
region_clients=None,
fetch_subcloud_ips=utils.fetch_subcloud_mgmt_ips,
).keystone_client
endpoint = sc_os_client.endpoint_cache.get_endpoint('sysinv')
sysinv_client = SysinvClient(subcloud_region, sc_os_client.session,
endpoint=endpoint)
except (keystone_exceptions.EndpointNotFound,
keystone_exceptions.ConnectFailure,
keystone_exceptions.ConnectTimeout,
IndexError):
LOG.exception("Endpoint for online subcloud %s not found, skip "
"firmware audit." % subcloud_name)
return
# Retrieve all the devices that are present in this subcloud.
try:

53
distributedcloud/dcmanager/audit/kube_rootca_update_audit.py
View File

@@ -4,7 +4,6 @@
# SPDX-License-Identifier: Apache-2.0
#
from keystoneauth1 import exceptions as keystone_exceptions
from oslo_config import cfg
from oslo_log import log as logging
@@ -14,7 +13,6 @@ from fm_api.constants import FM_ALARM_ID_CERT_EXPIRING_SOON
from dccommon import consts as dccommon_consts
from dccommon import utils as dccommon_utils
from dccommon.drivers.openstack.fm import FmClient
from dccommon.drivers.openstack.sdk_platform import (
OptimizedOpenStackDriver as OpenStackDriver
)
@@ -82,7 +80,9 @@ class KubeRootcaUpdateAudit(Auditor):
f"{regionone_rootca_certid}.")
return regionone_rootca_certid
def subcloud_kube_rootca_audit(self, subcloud, regionone_rootca_certid):
def subcloud_kube_rootca_audit(
self, sysinv_client, fm_client, subcloud, regionone_rootca_certid
):
"""Perform an audit of kube root CA update info in a subcloud.
The audit logic is as follow:
@@ -94,37 +94,25 @@ class KubeRootcaUpdateAudit(Auditor):
subcloud doesn't have the API to get cert ID -> alarm based
region one cert ID -> cert based
:param sysinv_client: the sysinv client object
:param fm_client: the fm client object
:param subcloud: the subcloud obj
:param region_one_audit_data: the audit data of the region one
"""
subcloud_name = subcloud.name
subcloud_region = subcloud.region_name
LOG.info("Triggered %s audit for: %s" % (self.audit_type,
subcloud_name))
try:
sc_os_client = OpenStackDriver(
region_name=subcloud_region,
region_clients=None,
fetch_subcloud_ips=utils.fetch_subcloud_mgmt_ips,
).keystone_client
session = sc_os_client.session
endpoint = sc_os_client.endpoint_cache.get_endpoint('sysinv')
except (keystone_exceptions.EndpointNotFound,
keystone_exceptions.ConnectFailure,
keystone_exceptions.ConnectTimeout,
IndexError):
LOG.exception("Endpoint for online subcloud:(%s) not found, skip "
"%s audit." % (subcloud_name, self.audit_type))
return
# Firstly, apply alarm based audit against the subclouds deployed in
# the distributed cloud and the subcloud running on old software
# version that cannot search for the k8s root CA cert id.
if dccommon_utils.is_centos(subcloud.software_version) or \
not subcloud.rehomed:
self.subcloud_audit_alarm_based(subcloud_name, subcloud_region,
session)
self.subcloud_audit_alarm_based(
fm_client, subcloud_name, subcloud_region
)
return
# Skip the audit if cannot get the region one cert ID.
@@ -135,8 +123,6 @@ class KubeRootcaUpdateAudit(Auditor):
return
try:
sysinv_client = SysinvClient(subcloud_region, session,
endpoint=endpoint)
success, subcloud_cert_data = \
sysinv_client.get_kube_rootca_cert_id()
except Exception:
@@ -149,31 +135,24 @@ class KubeRootcaUpdateAudit(Auditor):
# if not success, the subcloud is a Debian based subcloud without
# the sysinv API to get the cert ID, audit the subcloud based on
# its alarm.
self.subcloud_audit_alarm_based(subcloud_name, subcloud_region,
session)
self.subcloud_audit_alarm_based(
fm_client, subcloud_name, subcloud_region
)
else:
self.subcloud_audit_cert_based(subcloud_name, subcloud_region,
subcloud_cert_data,
regionone_rootca_certid)
def subcloud_audit_alarm_based(self, subcloud_name,
subcloud_region, session):
def subcloud_audit_alarm_based(
self, fm_client, subcloud_name, subcloud_region
):
"""The subcloud doesn't have the method to get Kubernetes root CA
cert ID, use alarm based audit.
:param fm_client: the fm client object
:param subcloud_name: the name of the subcloud
:param subcloud_region: the region of the subcloud
:param session: the keystone session of the subcloud
"""
try:
fm_client = FmClient(subcloud_region, session)
except (keystone_exceptions.EndpointNotFound,
keystone_exceptions.ConnectFailure,
keystone_exceptions.ConnectTimeout,
IndexError):
LOG.exception("Endpoint for online subcloud:(%s) not found, skip "
"%s audit." % (subcloud_name, self.audit_type))
return
out_of_sync = False
detected_alarms = fm_client.get_alarms_by_ids(KUBE_ROOTCA_ALARM_LIST)

22
distributedcloud/dcmanager/audit/kubernetes_audit.py
View File

@@ -15,7 +15,6 @@
# limitations under the License.
#
from keystoneauth1 import exceptions as keystone_exceptions
from oslo_log import log as logging
from dccommon import consts as dccommon_consts
@@ -96,8 +95,11 @@ class KubernetesAudit(object):
LOG.debug("RegionOne kubernetes versions: %s" % region_one_data)
return region_one_data
def subcloud_kubernetes_audit(self, subcloud_name, subcloud_region, audit_data):
def subcloud_kubernetes_audit(
self, sysinv_client, subcloud_name, subcloud_region, audit_data
):
LOG.info('Triggered kubernetes audit for: %s' % subcloud_name)
if not audit_data:
self._update_subcloud_sync_status(
subcloud_name,
@@ -105,22 +107,6 @@ class KubernetesAudit(object):
dccommon_consts.SYNC_STATUS_IN_SYNC)
LOG.debug('No region one audit data, exiting kubernetes audit')
return
try:
sc_os_client = OpenStackDriver(
region_name=subcloud_region,
region_clients=None,
fetch_subcloud_ips=utils.fetch_subcloud_mgmt_ips,
).keystone_client
endpoint = sc_os_client.endpoint_cache.get_endpoint('sysinv')
sysinv_client = SysinvClient(subcloud_region, sc_os_client.session,
endpoint=endpoint)
except (keystone_exceptions.EndpointNotFound,
keystone_exceptions.ConnectFailure,
keystone_exceptions.ConnectTimeout,
IndexError):
LOG.exception("Endpoint for online subcloud:(%s) not found, skip "
"kubernetes audit." % subcloud_name)
return
# Retrieve kubernetes info for this subcloud
# state - active, partial, available

26
distributedcloud/dcmanager/audit/patch_audit.py
View File

@@ -24,6 +24,7 @@ from dccommon.drivers.openstack.sdk_platform import (
OptimizedOpenStackDriver as OpenStackDriver
)
from dccommon.drivers.openstack.sysinv_v1 import SysinvClient
from dccommon.endpoint_cache import build_subcloud_endpoint
from dcmanager.common import utils
LOG = logging.getLogger(__name__)
@@ -136,24 +137,19 @@ class PatchAudit(object):
return PatchAuditData(regionone_patches, applied_patch_ids,
committed_patch_ids, regionone_software_version)
def subcloud_patch_audit(self, subcloud_name, subcloud_region, audit_data,
do_load_audit):
def subcloud_patch_audit(
self, keystone_client, sysinv_client, subcloud_management_ip, subcloud_name,
subcloud_region, audit_data, do_load_audit
):
LOG.info('Triggered patch audit for: %s.' % subcloud_name)
try:
sc_os_client = OpenStackDriver(
region_name=subcloud_region,
region_clients=None,
fetch_subcloud_ips=utils.fetch_subcloud_mgmt_ips,
).keystone_client
session = sc_os_client.session
patching_endpoint = sc_os_client.endpoint_cache.get_endpoint('patching')
sysinv_endpoint = sc_os_client.endpoint_cache.get_endpoint('sysinv')
patching_endpoint = build_subcloud_endpoint(
subcloud_management_ip, "patching"
)
patching_client = PatchingClient(
subcloud_region, session,
endpoint=patching_endpoint)
sysinv_client = SysinvClient(
subcloud_region, session,
endpoint=sysinv_endpoint)
subcloud_region, keystone_client.session, endpoint=patching_endpoint
)
except (keystone_exceptions.EndpointNotFound,
keystone_exceptions.ConnectFailure,
keystone_exceptions.ConnectTimeout,

18
distributedcloud/dcmanager/audit/software_audit.py
View File

@@ -10,6 +10,7 @@ from oslo_log import log as logging
from dccommon import consts as dccommon_consts
from dccommon.drivers.openstack import sdk_platform
from dccommon.drivers.openstack import software_v1
from dccommon.endpoint_cache import build_subcloud_endpoint
from dcmanager.common import utils
LOG = logging.getLogger(__name__)
@@ -110,20 +111,17 @@ class SoftwareAudit(object):
regionone_releases, deployed_release_ids, committed_release_ids
)
def subcloud_software_audit(self, subcloud_name, subcloud_region, audit_data):
def subcloud_software_audit(
self, keystone_client, subcloud_management_ip, subcloud_name,
subcloud_region, audit_data
):
LOG.info(f"Triggered software audit for: {subcloud_name}.")
try:
sc_os_client = sdk_platform.OptimizedOpenStackDriver(
region_name=subcloud_region,
region_clients=None,
fetch_subcloud_ips=utils.fetch_subcloud_mgmt_ips,
).keystone_client
session = sc_os_client.session
software_endpoint = sc_os_client.endpoint_cache.get_endpoint(
dccommon_consts.ENDPOINT_TYPE_SOFTWARE
software_endpoint = build_subcloud_endpoint(
subcloud_management_ip, dccommon_consts.ENDPOINT_TYPE_SOFTWARE
)
software_client = software_v1.SoftwareClient(
subcloud_region, session, endpoint=software_endpoint
subcloud_region, keystone_client.session, endpoint=software_endpoint
)
except (
keystone_exceptions.EndpointNotFound,

58
distributedcloud/dcmanager/audit/subcloud_audit_worker_manager.py
View File

@@ -21,9 +21,12 @@ from oslo_config import cfg
from oslo_log import log as logging
from dccommon import consts as dccommon_consts
from dccommon.drivers.openstack.fm import FmClient
from dccommon.drivers.openstack.sdk_platform import (
OptimizedOpenStackDriver as OpenStackDriver
)
from dccommon.drivers.openstack.sysinv_v1 import SysinvClient
from dccommon.endpoint_cache import build_subcloud_endpoint
from dcmanager.audit import alarm_aggregation
from dcmanager.audit import firmware_audit
from dcmanager.audit import kube_rootca_update_audit
@@ -349,24 +352,30 @@ class SubcloudAuditWorkerManager(manager.Manager):
audit_fail_count = subcloud.audit_fail_count
subcloud_name = subcloud.name
subcloud_region = subcloud.region_name
subcloud_management_ip = subcloud.management_start_ip
audits_done = list()
failures = list()
# Set defaults to None and disabled so we will still set disabled
# status if we encounter an error.
keystone_client = None
sysinv_client = None
fm_client = None
avail_to_set = dccommon_consts.AVAILABILITY_OFFLINE
try:
os_client = OpenStackDriver(
keystone_client = OpenStackDriver(
region_name=subcloud_region,
thread_name="subcloud-audit",
region_clients=["fm", "sysinv"],
fetch_subcloud_ips=utils.fetch_subcloud_mgmt_ips,
region_clients=None,
fetch_subcloud_ips=utils.fetch_subcloud_mgmt_ips
).keystone_client
admin_session = keystone_client.session
sysinv_client = SysinvClient(
subcloud_region, admin_session, endpoint=build_subcloud_endpoint(
subcloud_management_ip, "sysinv"
)
)
sysinv_client = os_client.sysinv_client
fm_client = os_client.fm_client
fm_client = FmClient(subcloud_region, admin_session)
except keystone_exceptions.ConnectTimeout:
if avail_status_current == dccommon_consts.AVAILABILITY_OFFLINE:
LOG.debug("Identity or Platform endpoint for %s not "
@@ -405,7 +414,7 @@ class SubcloudAuditWorkerManager(manager.Manager):
"subcloud: %s not found." % subcloud_name)
except Exception:
LOG.exception("Failed to get OS Client for subcloud: %s"
LOG.exception("Failed to create clients for subcloud: %s"
% subcloud_name)
# Check availability of the subcloud
@@ -479,10 +488,11 @@ class SubcloudAuditWorkerManager(manager.Manager):
# If we have patch audit data, audit the subcloud
if do_patch_audit and patch_audit_data:
try:
self.patch_audit.subcloud_patch_audit(subcloud_name,
subcloud_region,
patch_audit_data,
do_load_audit)
self.patch_audit.subcloud_patch_audit(
keystone_client, sysinv_client, subcloud_management_ip,
subcloud_name, subcloud_region, patch_audit_data,
do_load_audit
)
audits_done.append('patch')
if do_load_audit:
audits_done.append('load')
@@ -496,9 +506,10 @@ class SubcloudAuditWorkerManager(manager.Manager):
# Perform firmware audit
if do_firmware_audit:
try:
self.firmware_audit.subcloud_firmware_audit(subcloud_name,
subcloud_region,
firmware_audit_data)
self.firmware_audit.subcloud_firmware_audit(
sysinv_client, subcloud_name, subcloud_region,
firmware_audit_data
)
audits_done.append('firmware')
except Exception:
LOG.exception(failmsg % (subcloud.name, 'firmware'))
@@ -507,9 +518,9 @@ class SubcloudAuditWorkerManager(manager.Manager):
if do_kubernetes_audit:
try:
self.kubernetes_audit.subcloud_kubernetes_audit(
subcloud_name,
subcloud_region,
kubernetes_audit_data)
sysinv_client, subcloud_name, subcloud_region,
kubernetes_audit_data
)
audits_done.append('kubernetes')
except Exception:
LOG.exception(failmsg % (subcloud.name, 'kubernetes'))
@@ -518,19 +529,22 @@ class SubcloudAuditWorkerManager(manager.Manager):
if do_kube_rootca_update_audit:
try:
self.kube_rootca_update_audit.subcloud_kube_rootca_audit(
subcloud, kube_rootca_update_audit_data)
sysinv_client, fm_client, subcloud,
kube_rootca_update_audit_data
)
audits_done.append('kube-rootca-update')
except Exception:
LOG.exception(failmsg % (subcloud.name,
'kube-rootca-update'))
failures.append('kube-rootca-update')
# Audit openstack application in the subcloud
if do_audit_openstack and sysinv_client:
if do_audit_openstack:
# We don't want an exception here to cause our
# audits_done to be empty:
try:
self._audit_subcloud_openstack_app(
subcloud_region, sysinv_client, subcloud.openstack_installed)
subcloud_region, sysinv_client, subcloud.openstack_installed
)
except Exception:
LOG.exception(failmsg % (subcloud.name, 'openstack'))
failures.append('openstack')
@@ -538,7 +552,9 @@ class SubcloudAuditWorkerManager(manager.Manager):
if do_software_audit:
try:
self.software_audit.subcloud_software_audit(
subcloud_name, subcloud_region, software_audit_data)
keystone_client, subcloud_management_ip,
subcloud_name, subcloud_region, software_audit_data
)
audits_done.append('software')
except Exception:
LOG.exception(failmsg % (subcloud.name, 'software'))

19
distributedcloud/dcmanager/tests/base.py
View File

@@ -31,7 +31,8 @@ from sqlalchemy.engine import Engine
from sqlalchemy import event
from dccommon.utils import AnsiblePlaybook
from dcmanager.audit import rpcapi as audit_rpc_client
from dcmanager.audit import rpcapi
from dcmanager.audit import subcloud_audit_manager
from dcmanager.common import consts
from dcmanager.common import phased_subcloud_deploy as psd_common
from dcmanager.common import utils as dutils
@@ -176,7 +177,7 @@ class DCManagerTestCase(base.BaseTestCase):
def _mock_audit_rpc_client(self):
"""Mock rpc's manager audit client"""
mock_patch_object = mock.patch.object(audit_rpc_client, 'ManagerAuditClient')
mock_patch_object = mock.patch.object(rpcapi, 'ManagerAuditClient')
self.mock_audit_rpc_client = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
@@ -194,6 +195,20 @@ class DCManagerTestCase(base.BaseTestCase):
self.mock_rpc_subcloud_state_client = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_rpc_api_manager_audit_worker_client(self):
"""Mock rpc's api manager audit worker client"""
mock_patch_object = mock.patch.object(rpcapi, 'ManagerAuditWorkerClient')
self.mock_rpc_api_manager_audit_worker_client = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_subcloud_audit_manager_context(self):
"""Mock subcloud audit manager's context"""
mock_patch_object = mock.patch.object(subcloud_audit_manager, 'context')
self.mock_subcloud_audit_manager_context = mock_patch_object.start()
self.addCleanup(mock_patch_object.stop)
def _mock_openstack_driver(self, target):
"""Mock the target's OpenStackDriver"""

82
distributedcloud/dcmanager/tests/unit/audit/test_firmware_audit_manager.py
View File

@@ -21,6 +21,7 @@ from dccommon import consts as dccommon_consts
from dcmanager.audit import firmware_audit
from dcmanager.audit import patch_audit
from dcmanager.audit import subcloud_audit_manager
from dcmanager.audit import subcloud_audit_worker_manager
from dcmanager.tests import base
from dcmanager.tests import utils
@@ -252,7 +253,7 @@ class FakeSysinvClientImageWithoutLabels(object):
class FakeSysinvClientImageNotApplied(object):
def __init__(self, region, session, endpoint):
def __init__(self, region=None, session=None, endpoint=None):
self.region = region
self.session = session
self.endpoint = endpoint
@@ -281,7 +282,7 @@ class FakeSysinvClientImageNotApplied(object):
class FakeSysinvClientImageNotWritten(object):
def __init__(self, region, session, endpoint):
def __init__(self, region=None, session=None, endpoint=None):
self.region = region
self.session = session
self.endpoint = endpoint
@@ -413,6 +414,8 @@ class TestFirmwareAudit(base.DCManagerTestCase):
self.mock_audit_worker_api.return_value = self.fake_audit_worker_api
self.addCleanup(p.stop)
self._mock_sysinv_client(subcloud_audit_worker_manager)
def _rpc_convert(self, object_list):
# Convert to dict like what would happen calling via RPC
dict_results = []
@@ -421,13 +424,8 @@ class TestFirmwareAudit(base.DCManagerTestCase):
return dict_results
def get_fw_audit_data(self, am):
(
_,
firmware_audit_data,
_,
_,
_
) = am._get_audit_data(True, True, True, True, True)
(_, firmware_audit_data, _, _, _) = \
am._get_audit_data(True, True, True, True, True)
# Convert to dict like what would happen calling via RPC
firmware_audit_data = self._rpc_convert(firmware_audit_data)
@@ -465,13 +463,15 @@ class TestFirmwareAudit(base.DCManagerTestCase):
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
fm.subcloud_firmware_audit(name, region, firmware_audit_data)
fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, region, firmware_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
subcloud_region=region,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_FIRMWARE,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)]
mock.call(
mock.ANY, subcloud_name=name, subcloud_region=region,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_FIRMWARE,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)
]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status. \
assert_has_calls(expected_calls)
@@ -500,13 +500,16 @@ class TestFirmwareAudit(base.DCManagerTestCase):
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
fm.subcloud_firmware_audit(name, region, firmware_audit_data)
fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, region, firmware_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
subcloud_region=region,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_FIRMWARE,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)]
mock.call(
mock.ANY, subcloud_name=name, subcloud_region=region,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_FIRMWARE,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC
)
]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status. \
assert_has_calls(expected_calls)
@@ -534,13 +537,16 @@ class TestFirmwareAudit(base.DCManagerTestCase):
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
fm.subcloud_firmware_audit(name, region, firmware_audit_data)
fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, region, firmware_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
subcloud_region=region,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_FIRMWARE,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)]
mock.call(
mock.ANY, subcloud_name=name, subcloud_region=region,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_FIRMWARE,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC
)
]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status. \
assert_has_calls(expected_calls)
@@ -558,6 +564,7 @@ class TestFirmwareAudit(base.DCManagerTestCase):
mock_sysinv_client):
mock_context.get_admin_context.return_value = self.ctxt
mock_fw_sysinv_client.side_effect = FakeSysinvClientImageNotApplied
self.mock_sysinv_client.side_effect = FakeSysinvClientImageNotApplied
fm = firmware_audit.FirmwareAudit(self.ctxt,
self.fake_dcmanager_state_api)
@@ -568,7 +575,9 @@ class TestFirmwareAudit(base.DCManagerTestCase):
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
fm.subcloud_firmware_audit(name, region, firmware_audit_data)
fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, region, firmware_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
@@ -592,6 +601,7 @@ class TestFirmwareAudit(base.DCManagerTestCase):
mock_sysinv_client):
mock_context.get_admin_context.return_value = self.ctxt
mock_fw_sysinv_client.side_effect = FakeSysinvClientImageNotWritten
self.mock_sysinv_client.side_effect = FakeSysinvClientImageNotWritten
fm = firmware_audit.FirmwareAudit(self.ctxt,
self.fake_dcmanager_state_api)
@@ -602,7 +612,9 @@ class TestFirmwareAudit(base.DCManagerTestCase):
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
fm.subcloud_firmware_audit(name, region, firmware_audit_data)
fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, region, firmware_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
@@ -636,7 +648,9 @@ class TestFirmwareAudit(base.DCManagerTestCase):
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
fm.subcloud_firmware_audit(name, region, firmware_audit_data)
fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, region, firmware_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
@@ -670,7 +684,9 @@ class TestFirmwareAudit(base.DCManagerTestCase):
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
fm.subcloud_firmware_audit(name, region, firmware_audit_data)
fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, region, firmware_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
@@ -704,7 +720,9 @@ class TestFirmwareAudit(base.DCManagerTestCase):
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
fm.subcloud_firmware_audit(name, region, firmware_audit_data)
fm.subcloud_firmware_audit(
self.mock_sysinv_client(), name, region, firmware_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,

26
distributedcloud/dcmanager/tests/unit/audit/test_kube_audit_manager.py
View File

@@ -23,6 +23,7 @@ from dcmanager.audit import firmware_audit
from dcmanager.audit import kubernetes_audit
from dcmanager.audit import patch_audit
from dcmanager.audit import subcloud_audit_manager
from dcmanager.audit import subcloud_audit_worker_manager
from dcmanager.tests import base
from dcmanager.tests import utils
@@ -132,6 +133,8 @@ class TestKubernetesAudit(base.DCManagerTestCase):
self.mock_kube_audit_sys.return_value = self.kube_sysinv_client
self.addCleanup(p.stop)
self._mock_sysinv_client(subcloud_audit_worker_manager)
# Set the kube upgrade objects as being empty for all regions
self.kube_sysinv_client.get_kube_upgrades.return_value = []
@@ -175,7 +178,9 @@ class TestKubernetesAudit(base.DCManagerTestCase):
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
audit.subcloud_kubernetes_audit(name, region, kubernetes_audit_data)
audit.subcloud_kubernetes_audit(
self.mock_sysinv_client(), name, region, kubernetes_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
@@ -206,7 +211,9 @@ class TestKubernetesAudit(base.DCManagerTestCase):
self.kube_sysinv_client.get_kube_versions.return_value = [
FakeKubeVersion(version=PREVIOUS_KUBE_VERSION),
]
audit.subcloud_kubernetes_audit(name, region, kubernetes_audit_data)
audit.subcloud_kubernetes_audit(
self.mock_sysinv_client(), name, region, kubernetes_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
@@ -237,7 +244,9 @@ class TestKubernetesAudit(base.DCManagerTestCase):
self.kube_sysinv_client.get_kube_versions.return_value = [
FakeKubeVersion(version=UPGRADED_KUBE_VERSION),
]
audit.subcloud_kubernetes_audit(name, region, kubernetes_audit_data)
audit.subcloud_kubernetes_audit(
self.mock_sysinv_client(), name, region, kubernetes_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
@@ -260,6 +269,9 @@ class TestKubernetesAudit(base.DCManagerTestCase):
self.kube_sysinv_client.get_kube_versions.return_value = [
FakeKubeVersion(version=UPGRADED_KUBE_VERSION),
]
self.mock_sysinv_client().get_kube_versions.return_value = [
FakeKubeVersion(version=UPGRADED_KUBE_VERSION)
]
kubernetes_audit_data = self.get_kube_audit_data(am)
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
@@ -269,7 +281,9 @@ class TestKubernetesAudit(base.DCManagerTestCase):
self.kube_sysinv_client.get_kube_versions.return_value = [
FakeKubeVersion(version=UPGRADED_KUBE_VERSION),
]
audit.subcloud_kubernetes_audit(name, region, kubernetes_audit_data)
audit.subcloud_kubernetes_audit(
self.mock_sysinv_client(), name, region, kubernetes_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
@@ -307,7 +321,9 @@ class TestKubernetesAudit(base.DCManagerTestCase):
self.kube_sysinv_client.get_kube_versions.return_value = [
FakeKubeVersion(version=UPGRADED_KUBE_VERSION),
]
audit.subcloud_kubernetes_audit(name, region, kubernetes_audit_data)
audit.subcloud_kubernetes_audit(
self.mock_sysinv_client(), name, region, kubernetes_audit_data
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,

344
distributedcloud/dcmanager/tests/unit/audit/test_kube_rootca_update_audit_manager.py
View File

@@ -1,5 +1,5 @@
#
# Copyright (c) 2023 Wind River Systems, Inc.
# Copyright (c) 2023-2024 Wind River Systems, Inc.
#
# SPDX-License-Identifier: Apache-2.0
#
@@ -8,35 +8,9 @@ import mock
from dccommon import consts as dccommon_consts
from dcmanager.audit import kube_rootca_update_audit
from dcmanager.audit import subcloud_audit_manager
from dcmanager.audit.subcloud_audit_manager import SubcloudAuditManager
from dcmanager.audit import subcloud_audit_worker_manager
from dcmanager.tests import base
from dcmanager.tests import utils
class FakeDCManagerStateAPI(object):
def __init__(self):
self.update_subcloud_availability = mock.MagicMock()
self.update_subcloud_endpoint_status = mock.MagicMock()
class FakeAuditWorkerAPI(object):
def __init__(self):
self.audit_subclouds = mock.MagicMock()
class FakeSysinvClient(object):
def __init__(self):
self.region = None
self.session = None
self.get_kube_rootca_cert_id = mock.MagicMock()
class FakeFmClient(object):
def __init__(self):
self.region = None
self.session = None
self.get_alarms_by_ids = mock.MagicMock()
class FakeKubeRootcaData(object):
@@ -60,349 +34,333 @@ class FakeSubcloudObj(object):
class TestKubeRootcaUpdateAudit(base.DCManagerTestCase):
def setUp(self):
super(TestKubeRootcaUpdateAudit, self).setUp()
self.ctxt = utils.dummy_context()
super().setUp()
# Mock the DCManager subcloud state API
self.fake_dcmanager_state_api = FakeDCManagerStateAPI()
p = mock.patch('dcmanager.rpc.client.SubcloudStateClient')
self.mock_dcmanager_state_api = p.start()
self.mock_dcmanager_state_api.return_value = \
self.fake_dcmanager_state_api
self.addCleanup(p.stop)
# Mock the Audit Worker API
self.fake_audit_worker_api = FakeAuditWorkerAPI()
p = mock.patch('dcmanager.audit.rpcapi.ManagerAuditWorkerClient')
self.mock_audit_worker_api = p.start()
self.mock_audit_worker_api.return_value = self.fake_audit_worker_api
self.addCleanup(p.stop)
# Note: mock where an item is used, not where it comes from
p = mock.patch.object(kube_rootca_update_audit, 'OpenStackDriver')
self.rootca_openstack_driver = mock.MagicMock()
self.mock_rootca_audit_driver = p.start()
self.mock_rootca_audit_driver.return_value = self.rootca_openstack_driver
self.addCleanup(p.stop)
p = mock.patch.object(kube_rootca_update_audit, 'SysinvClient')
self.rootca_sysinv_client = FakeSysinvClient()
self.mock_rootca_audit_sys = p.start()
self.mock_rootca_audit_sys.return_value = self.rootca_sysinv_client
self.addCleanup(p.stop)
p = mock.patch.object(kube_rootca_update_audit, 'FmClient')
self.rootca_fm_client = FakeFmClient()
self.mock_rootca_audit_fm = p.start()
self.mock_rootca_audit_fm.return_value = self.rootca_fm_client
self.addCleanup(p.stop)
self._mock_openstack_driver(kube_rootca_update_audit)
self._mock_openstack_driver(subcloud_audit_worker_manager)
self._mock_sysinv_client(kube_rootca_update_audit)
self.mock_region_one_sysinv_client = self.mock_sysinv_client
self._mock_sysinv_client(subcloud_audit_worker_manager)
self._mock_fm_client(subcloud_audit_worker_manager)
self._mock_rpc_subcloud_state_client()
self._mock_rpc_api_manager_audit_worker_client()
self._mock_subcloud_audit_manager_context()
# Set the Kubeernetes Root CA cert identifier as cert1 for all regions
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert1", "")
# Set get_alarms_by_ids returns none by default
self.rootca_fm_client.get_alarms_by_ids.return_value = None
self.mock_fm_client().get_alarms_by_ids.return_value = None
self.mock_subcloud_audit_manager_context.\
get_admin_context.return_value = self.ctx
def get_rootca_audit_data(self, am):
(
_,
_,
_,
kube_rootca_audit_data,
_
) = am._get_audit_data(True, True, True, True, True)
(_, _, _, kube_rootca_audit_data, _) = \
am._get_audit_data(True, True, True, True, True)
return kube_rootca_audit_data
def test_init(self):
audit = kube_rootca_update_audit.KubeRootcaUpdateAudit(
self.ctxt, self.fake_dcmanager_state_api)
self.ctx, self.mock_rpc_subcloud_state_client
)
self.assertIsNotNone(audit)
self.assertEqual(self.ctxt, audit.context)
self.assertEqual(self.fake_dcmanager_state_api,
audit.state_rpc_client)
@mock.patch.object(subcloud_audit_manager, 'context')
def test_no_kube_rootca_update_audit_data_to_sync(self, mock_context):
mock_context.get_admin_context.return_value = self.ctxt
self.assertEqual(self.ctx, audit.context)
self.assertEqual(
self.mock_rpc_subcloud_state_client, audit.state_rpc_client
)
def test_no_kube_rootca_update_audit_data_to_sync(self):
audit = kube_rootca_update_audit.KubeRootcaUpdateAudit(
self.ctxt, self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
self.ctx, self.mock_rpc_subcloud_state_client
)
am = SubcloudAuditManager()
am.kube_rootca_update_audit = audit
# Set the region one data
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("", "error")
kube_rootca_update_audit_data = self.get_rootca_audit_data(am)
subclouds = [base.SUBCLOUD_1, base.SUBCLOUD_2]
for subcloud_dict in subclouds:
subcloud = FakeSubcloudObj(subcloud_dict)
audit.subcloud_kube_rootca_audit(subcloud,
kube_rootca_update_audit_data)
audit.subcloud_kube_rootca_audit(
self.mock_sysinv_client(), self.mock_fm_client(), subcloud,
kube_rootca_update_audit_data
)
expected_calls = [
mock.call(
mock.ANY, subcloud_name=subcloud.name,
subcloud_region=subcloud.region_name,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_KUBE_ROOTCA,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status.\
self.mock_rpc_subcloud_state_client.update_subcloud_endpoint_status.\
assert_has_calls(expected_calls)
@mock.patch.object(subcloud_audit_manager, 'context')
def test_kube_rootca_update_audit_in_sync_cert_based(self,
mock_context):
mock_context.get_admin_context.return_value = self.ctxt
def test_kube_rootca_update_audit_in_sync_cert_based(self):
audit = kube_rootca_update_audit.KubeRootcaUpdateAudit(
self.ctxt, self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
self.ctx, self.mock_rpc_subcloud_state_client
)
am = SubcloudAuditManager()
am.kube_rootca_update_audit = audit
# Set the region one data
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert1", "")
kube_rootca_update_audit_data = self.get_rootca_audit_data(am)
subclouds = [base.SUBCLOUD_1, base.SUBCLOUD_2]
for subcloud_dict in subclouds:
subcloud = FakeSubcloudObj(subcloud_dict)
# return same kube root ca ID in the subclouds
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.\
return_value = True, FakeKubeRootcaData("cert1", "")
self.mock_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert1", "")
audit.subcloud_kube_rootca_audit(subcloud,
kube_rootca_update_audit_data)
audit.subcloud_kube_rootca_audit(
self.mock_sysinv_client(), self.mock_fm_client(), subcloud,
kube_rootca_update_audit_data
)
expected_calls = [
mock.call(
mock.ANY, subcloud_name=subcloud.name,
subcloud_region=subcloud.region_name,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_KUBE_ROOTCA,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status.\
self.mock_rpc_subcloud_state_client.update_subcloud_endpoint_status.\
assert_has_calls(expected_calls)
@mock.patch.object(subcloud_audit_manager, 'context')
def test_kube_rootca_update_audit_out_of_sync_cert_based(self,
mock_context):
mock_context.get_admin_context.return_value = self.ctxt
def test_kube_rootca_update_audit_out_of_sync_cert_based(self):
audit = kube_rootca_update_audit.KubeRootcaUpdateAudit(
self.ctxt, self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
self.ctx, self.mock_rpc_subcloud_state_client
)
am = SubcloudAuditManager()
am.kube_rootca_update_audit = audit
# Set the region one data
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert1", "")
kube_rootca_update_audit_data = self.get_rootca_audit_data(am)
subclouds = [base.SUBCLOUD_1, base.SUBCLOUD_2]
for subcloud_dict in subclouds:
subcloud = FakeSubcloudObj(subcloud_dict)
# return different kube root ca ID in the subclouds
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.\
return_value = True, FakeKubeRootcaData("cert2", "")
self.mock_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert2", "")
audit.subcloud_kube_rootca_audit(subcloud,
kube_rootca_update_audit_data)
audit.subcloud_kube_rootca_audit(
self.mock_sysinv_client(), self.mock_fm_client(), subcloud,
kube_rootca_update_audit_data
)
expected_calls = [
mock.call(mock.ANY, subcloud_name=subcloud.name,
subcloud_region=subcloud.region_name,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_KUBE_ROOTCA,
sync_status=dccommon_consts.SYNC_STATUS_OUT_OF_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status.\
self.mock_rpc_subcloud_state_client.update_subcloud_endpoint_status.\
assert_has_calls(expected_calls)
@mock.patch.object(subcloud_audit_manager, 'context')
def test_kube_rootca_update_audit_in_sync_alarm_based(self,
mock_context):
mock_context.get_admin_context.return_value = self.ctxt
def test_kube_rootca_update_audit_in_sync_alarm_based(self):
audit = kube_rootca_update_audit.KubeRootcaUpdateAudit(
self.ctxt, self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
self.ctx, self.mock_rpc_subcloud_state_client
)
am = SubcloudAuditManager()
am.kube_rootca_update_audit = audit
# Set the region one data
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert1", "")
kube_rootca_update_audit_data = self.get_rootca_audit_data(am)
subclouds = [base.SUBCLOUD_1, base.SUBCLOUD_2]
for subcloud_dict in subclouds:
subcloud = FakeSubcloudObj(subcloud_dict)
# return API cert ID request failed
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.\
return_value = False, None
self.mock_sysinv_client().get_kube_rootca_cert_id.return_value = \
False, None
self.rootca_fm_client.get_alarms_by_ids.return_value = None
audit.subcloud_kube_rootca_audit(subcloud,
kube_rootca_update_audit_data)
self.mock_fm_client().get_alarms_by_ids.return_value = None
audit.subcloud_kube_rootca_audit(
self.mock_sysinv_client(), self.mock_fm_client(), subcloud,
kube_rootca_update_audit_data
)
expected_calls = [
mock.call(
mock.ANY, subcloud_name=subcloud.name,
subcloud_region=subcloud.region_name,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_KUBE_ROOTCA,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status.\
self.mock_rpc_subcloud_state_client.update_subcloud_endpoint_status.\
assert_has_calls(expected_calls)
@mock.patch.object(subcloud_audit_manager, 'context')
def test_kube_rootca_update_audit_out_of_sync_alarm_based(self,
mock_context):
mock_context.get_admin_context.return_value = self.ctxt
def test_kube_rootca_update_audit_out_of_sync_alarm_based(self):
audit = kube_rootca_update_audit.KubeRootcaUpdateAudit(
self.ctxt, self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
self.ctx, self.mock_rpc_subcloud_state_client
)
am = SubcloudAuditManager()
am.kube_rootca_update_audit = audit
# Set the region one data
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert1", "")
kube_rootca_update_audit_data = self.get_rootca_audit_data(am)
subclouds = [base.SUBCLOUD_1, base.SUBCLOUD_2]
for subcloud_dict in subclouds:
subcloud = FakeSubcloudObj(subcloud_dict)
# return API cert ID request failed
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.\
return_value = False, None
self.mock_sysinv_client().get_kube_rootca_cert_id.return_value = \
False, None
self.rootca_fm_client.get_alarms_by_ids.return_value = \
self.mock_fm_client().get_alarms_by_ids.return_value = \
[FakeAlarm('system.certificate.kubernetes-root-ca'), ]
audit.subcloud_kube_rootca_audit(subcloud,
kube_rootca_update_audit_data)
audit.subcloud_kube_rootca_audit(
self.mock_sysinv_client(), self.mock_fm_client(), subcloud,
kube_rootca_update_audit_data
)
expected_calls = [
mock.call(
mock.ANY, subcloud_name=subcloud.name,
subcloud_region=subcloud.region_name,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_KUBE_ROOTCA,
sync_status=dccommon_consts.SYNC_STATUS_OUT_OF_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status.\
self.mock_rpc_subcloud_state_client.update_subcloud_endpoint_status.\
assert_has_calls(expected_calls)
@mock.patch.object(subcloud_audit_manager, 'context')
def test_kube_rootca_update_audit_in_sync_old_release(self,
mock_context):
mock_context.get_admin_context.return_value = self.ctxt
def test_kube_rootca_update_audit_in_sync_old_release(self):
audit = kube_rootca_update_audit.KubeRootcaUpdateAudit(
self.ctxt, self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
self.ctx, self.mock_rpc_subcloud_state_client
)
am = SubcloudAuditManager()
am.kube_rootca_update_audit = audit
# Set the region one data
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert1", "")
kube_rootca_update_audit_data = self.get_rootca_audit_data(am)
subclouds = [base.SUBCLOUD_3, base.SUBCLOUD_4]
for subcloud_dict in subclouds:
subcloud = FakeSubcloudObj(subcloud_dict)
# return API cert ID request failed
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
False, None
self.rootca_fm_client.get_alarms_by_ids.return_value = None
audit.subcloud_kube_rootca_audit(subcloud,
kube_rootca_update_audit_data)
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.\
return_value = False, None
self.mock_fm_client().get_alarms_by_ids.return_value = None
audit.subcloud_kube_rootca_audit(
self.mock_sysinv_client(), self.mock_fm_client(), subcloud,
kube_rootca_update_audit_data
)
expected_calls = [
mock.call(
mock.ANY, subcloud_name=subcloud.name,
subcloud_region=subcloud.region_name,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_KUBE_ROOTCA,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status.\
self.mock_rpc_subcloud_state_client.update_subcloud_endpoint_status.\
assert_has_calls(expected_calls)
@mock.patch.object(subcloud_audit_manager, 'context')
def test_kube_rootca_update_audit_out_of_sync_old_release(self,
mock_context):
mock_context.get_admin_context.return_value = self.ctxt
def test_kube_rootca_update_audit_out_of_sync_old_release(self):
audit = kube_rootca_update_audit.KubeRootcaUpdateAudit(
self.ctxt, self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
self.ctx, self.mock_rpc_subcloud_state_client
)
am = SubcloudAuditManager()
am.kube_rootca_update_audit = audit
# Set the region one data
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert1", "")
kube_rootca_update_audit_data = self.get_rootca_audit_data(am)
subclouds = [base.SUBCLOUD_3, base.SUBCLOUD_4]
for subcloud_dict in subclouds:
subcloud = FakeSubcloudObj(subcloud_dict)
# return API cert ID request failed
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
False, None
self.rootca_fm_client.get_alarms_by_ids.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.\
return_value = False, None
self.mock_fm_client().get_alarms_by_ids.return_value = \
[FakeAlarm('system.certificate.kubernetes-root-ca'), ]
audit.subcloud_kube_rootca_audit(subcloud,
kube_rootca_update_audit_data)
audit.subcloud_kube_rootca_audit(
self.mock_sysinv_client(), self.mock_fm_client(), subcloud,
kube_rootca_update_audit_data
)
expected_calls = [
mock.call(
mock.ANY, subcloud_name=subcloud.name,
subcloud_region=subcloud.region_name,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_KUBE_ROOTCA,
sync_status=dccommon_consts.SYNC_STATUS_OUT_OF_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status.\
self.mock_rpc_subcloud_state_client.update_subcloud_endpoint_status.\
assert_has_calls(expected_calls)
@mock.patch.object(subcloud_audit_manager, 'context')
def test_kube_rootca_update_audit_in_sync_not_rehomed(self,
mock_context):
mock_context.get_admin_context.return_value = self.ctxt
def test_kube_rootca_update_audit_in_sync_not_rehomed(self):
audit = kube_rootca_update_audit.KubeRootcaUpdateAudit(
self.ctxt, self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
self.ctx, self.mock_rpc_subcloud_state_client
)
am = SubcloudAuditManager()
am.kube_rootca_update_audit = audit
# Set the region one data
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert1", "")
kube_rootca_update_audit_data = self.get_rootca_audit_data(am)
subclouds = [base.SUBCLOUD_5, base.SUBCLOUD_6]
for subcloud_dict in subclouds:
subcloud = FakeSubcloudObj(subcloud_dict)
# return API cert ID request failed
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
False, None
self.rootca_fm_client.get_alarms_by_ids.return_value = None
audit.subcloud_kube_rootca_audit(subcloud,
kube_rootca_update_audit_data)
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.\
return_value = False, None
self.mock_fm_client().get_alarms_by_ids.return_value = None
audit.subcloud_kube_rootca_audit(
self.mock_sysinv_client(), self.mock_fm_client(), subcloud,
kube_rootca_update_audit_data
)
expected_calls = [
mock.call(
mock.ANY, subcloud_name=subcloud.name,
subcloud_region=subcloud.region_name,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_KUBE_ROOTCA,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status.\
self.mock_rpc_subcloud_state_client.update_subcloud_endpoint_status.\
assert_has_calls(expected_calls)
@mock.patch.object(subcloud_audit_manager, 'context')
def test_kube_rootca_update_audit_out_of_sync_not_rehomed(self,
mock_context):
mock_context.get_admin_context.return_value = self.ctxt
def test_kube_rootca_update_audit_out_of_sync_not_rehomed(self):
audit = kube_rootca_update_audit.KubeRootcaUpdateAudit(
self.ctxt, self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
self.ctx, self.mock_rpc_subcloud_state_client
)
am = SubcloudAuditManager()
am.kube_rootca_update_audit = audit
# Set the region one data
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.return_value = \
True, FakeKubeRootcaData("cert1", "")
kube_rootca_update_audit_data = self.get_rootca_audit_data(am)
subclouds = [base.SUBCLOUD_5, base.SUBCLOUD_6]
for subcloud_dict in subclouds:
subcloud = FakeSubcloudObj(subcloud_dict)
# return API cert ID request failed
self.rootca_sysinv_client.get_kube_rootca_cert_id.return_value = \
False, None
self.rootca_fm_client.get_alarms_by_ids.return_value = \
self.mock_region_one_sysinv_client().get_kube_rootca_cert_id.\
return_value = False, None
self.mock_fm_client().get_alarms_by_ids.return_value = \
[FakeAlarm('system.certificate.kubernetes-root-ca'), ]
audit.subcloud_kube_rootca_audit(subcloud,
kube_rootca_update_audit_data)
audit.subcloud_kube_rootca_audit(
self.mock_sysinv_client(), self.mock_fm_client(), subcloud,
kube_rootca_update_audit_data
)
expected_calls = [
mock.call(
mock.ANY, subcloud_name=subcloud.name,
subcloud_region=subcloud.region_name,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_KUBE_ROOTCA,
sync_status=dccommon_consts.SYNC_STATUS_OUT_OF_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status.\
self.mock_rpc_subcloud_state_client.update_subcloud_endpoint_status.\
assert_has_calls(expected_calls)

120
distributedcloud/dcmanager/tests/unit/audit/test_patch_audit_manager.py
View File

@@ -20,8 +20,8 @@ from oslo_config import cfg
from dccommon import consts as dccommon_consts
from dcmanager.audit import patch_audit
from dcmanager.audit import subcloud_audit_manager
from dcmanager.audit import subcloud_audit_worker_manager
from dcmanager.tests import base
from dcmanager.tests import utils
CONF = cfg.CONF
@@ -181,7 +181,7 @@ class FakePatchingClientExtraPatches(object):
class FakeSysinvClientOneLoad(object):
def __init__(self, region, session, endpoint):
def __init__(self, region=None, session=None, endpoint=None):
self.region = region
self.session = session
self.endpoint = endpoint
@@ -200,7 +200,7 @@ class FakeSysinvClientOneLoad(object):
class FakeSysinvClientOneLoadUnmatchedSoftwareVersion(object):
def __init__(self, region, session, endpoint):
def __init__(self, region=None, session=None, endpoint=None):
self.region = region
self.session = session
self.endpoint = endpoint
@@ -222,7 +222,7 @@ class FakeSysinvClientOneLoadUnmatchedSoftwareVersion(object):
class FakeSysinvClientOneLoadUpgradeInProgress(object):
def __init__(self, region, session, endpoint):
def __init__(self, region=None, session=None, endpoint=None):
self.region = region
self.session = session
self.endpoint = endpoint
@@ -246,7 +246,6 @@ class FakeSysinvClientOneLoadUpgradeInProgress(object):
class TestPatchAudit(base.DCManagerTestCase):
def setUp(self):
super().setUp()
self.ctxt = utils.dummy_context()
# Mock the DCManager subcloud state API
self.fake_dcmanager_state_api = FakeDCManagerStateAPI()
@@ -263,23 +262,21 @@ class TestPatchAudit(base.DCManagerTestCase):
self.mock_audit_worker_api.return_value = self.fake_audit_worker_api
self.addCleanup(p.stop)
self._mock_openstack_driver(subcloud_audit_worker_manager)
self._mock_sysinv_client(subcloud_audit_worker_manager)
def get_patch_audit_data(self, am):
(
patch_audit_data,
_,
_,
_,
_
) = am._get_audit_data(True, True, True, True, True)
(patch_audit_data, _, _, _, _) = \
am._get_audit_data(True, True, True, True, True)
# Convert to dict like what would happen calling via RPC
patch_audit_data = patch_audit_data.to_dict()
return patch_audit_data
def test_init(self):
pm = patch_audit.PatchAudit(self.ctxt,
pm = patch_audit.PatchAudit(self.ctx,
self.fake_dcmanager_state_api)
self.assertIsNotNone(pm)
self.assertEqual(self.ctxt, pm.context)
self.assertEqual(self.ctx, pm.context)
self.assertEqual(self.fake_dcmanager_state_api, pm.state_rpc_client)
@mock.patch.object(patch_audit, 'SysinvClient')
@@ -290,11 +287,12 @@ class TestPatchAudit(base.DCManagerTestCase):
mock_openstack_driver,
mock_patching_client,
mock_sysinv_client):
mock_context.get_admin_context.return_value = self.ctxt
mock_context.get_admin_context.return_value = self.ctx
mock_patching_client.side_effect = FakePatchingClientInSync
mock_sysinv_client.side_effect = FakeSysinvClientOneLoad
self.mock_sysinv_client.side_effect = FakeSysinvClientOneLoad
pm = patch_audit.PatchAudit(self.ctxt,
pm = patch_audit.PatchAudit(self.ctx,
self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
am.patch_audit = pm
@@ -304,17 +302,24 @@ class TestPatchAudit(base.DCManagerTestCase):
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
pm.subcloud_patch_audit(name, region, patch_audit_data, do_load_audit)
for index, subcloud in enumerate(subclouds.keys(), start=2):
subcloud_region = subclouds[subcloud]
pm.subcloud_patch_audit(
self.mock_openstack_driver(),
self.mock_sysinv_client(subcloud_region), f"192.168.1.{index}",
subcloud, subcloud_region, patch_audit_data, do_load_audit
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
subcloud_region=region,
subcloud_name=subcloud,
subcloud_region=subcloud_region,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_PATCHING,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC),
mock.call(mock.ANY,
subcloud_name=name,
subcloud_region=region,
subcloud_name=subcloud,
subcloud_region=subcloud_region,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_LOAD,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status. \
@@ -328,14 +333,15 @@ class TestPatchAudit(base.DCManagerTestCase):
mock_openstack_driver,
mock_patching_client,
mock_sysinv_client):
mock_context.get_admin_context.return_value = self.ctxt
pm = patch_audit.PatchAudit(self.ctxt,
mock_context.get_admin_context.return_value = self.ctx
pm = patch_audit.PatchAudit(self.ctx,
self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
am.patch_audit = pm
mock_patching_client.side_effect = FakePatchingClientOutOfSync
mock_sysinv_client.side_effect = FakeSysinvClientOneLoad
self.mock_sysinv_client.side_effect = FakeSysinvClientOneLoad
do_load_audit = True
patch_audit_data = self.get_patch_audit_data(am)
@@ -344,8 +350,14 @@ class TestPatchAudit(base.DCManagerTestCase):
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name'],
base.SUBCLOUD_3['name']: base.SUBCLOUD_3['region_name'],
base.SUBCLOUD_4['name']: base.SUBCLOUD_4['region_name']}
for name, region in subclouds.items():
pm.subcloud_patch_audit(name, region, patch_audit_data, do_load_audit)
for index, subcloud in enumerate(subclouds.keys(), start=2):
subcloud_region = subclouds[subcloud]
pm.subcloud_patch_audit(
self.mock_openstack_driver(),
self.mock_sysinv_client(subcloud_region), f"192.168.1.{index}",
subcloud, subcloud_region, patch_audit_data, do_load_audit
)
expected_calls = [
mock.call(mock.ANY,
@@ -401,31 +413,39 @@ class TestPatchAudit(base.DCManagerTestCase):
mock_openstack_driver,
mock_patching_client,
mock_sysinv_client):
mock_context.get_admin_context.return_value = self.ctxt
pm = patch_audit.PatchAudit(self.ctxt,
mock_context.get_admin_context.return_value = self.ctx
pm = patch_audit.PatchAudit(self.ctx,
self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
am.patch_audit = pm
mock_patching_client.side_effect = FakePatchingClientExtraPatches
mock_sysinv_client.side_effect = FakeSysinvClientOneLoad
self.mock_sysinv_client.side_effect = FakeSysinvClientOneLoad
do_load_audit = True
patch_audit_data = self.get_patch_audit_data(am)
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
pm.subcloud_patch_audit(name, region, patch_audit_data, do_load_audit)
for index, subcloud in enumerate(subclouds.keys(), start=2):
subcloud_region = subclouds[subcloud]
pm.subcloud_patch_audit(
self.mock_openstack_driver(),
self.mock_sysinv_client(subcloud_region), f"192.168.1.{index}",
subcloud, subcloud_region, patch_audit_data, do_load_audit
)
expected_calls = [
mock.call(mock.ANY,
subcloud_name=name,
subcloud_region=region,
subcloud_name=subcloud,
subcloud_region=subcloud_region,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_PATCHING,
sync_status=dccommon_consts.SYNC_STATUS_OUT_OF_SYNC),
mock.call(mock.ANY,
subcloud_name=name,
subcloud_region=region,
subcloud_name=subcloud,
subcloud_region=subcloud_region,
endpoint_type=dccommon_consts.ENDPOINT_TYPE_LOAD,
sync_status=dccommon_consts.SYNC_STATUS_IN_SYNC)]
self.fake_dcmanager_state_api.update_subcloud_endpoint_status.\
@@ -440,22 +460,30 @@ class TestPatchAudit(base.DCManagerTestCase):
mock_openstack_driver,
mock_patching_client,
mock_sysinv_client):
mock_context.get_admin_context.return_value = self.ctxt
pm = patch_audit.PatchAudit(self.ctxt,
mock_context.get_admin_context.return_value = self.ctx
pm = patch_audit.PatchAudit(self.ctx,
self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
am.patch_audit = pm
mock_patching_client.side_effect = FakePatchingClientInSync
mock_sysinv_client.side_effect = (
FakeSysinvClientOneLoadUnmatchedSoftwareVersion)
self.mock_sysinv_client.side_effect = \
FakeSysinvClientOneLoadUnmatchedSoftwareVersion
do_load_audit = True
patch_audit_data = self.get_patch_audit_data(am)
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
pm.subcloud_patch_audit(name, region, patch_audit_data, do_load_audit)
for index, subcloud in enumerate(subclouds.keys(), start=2):
subcloud_region = subclouds[subcloud]
pm.subcloud_patch_audit(
self.mock_openstack_driver(),
self.mock_sysinv_client(subcloud_region), f"192.168.1.{index}",
subcloud, subcloud_region, patch_audit_data, do_load_audit
)
expected_calls = [
mock.call(mock.ANY,
@@ -491,21 +519,29 @@ class TestPatchAudit(base.DCManagerTestCase):
mock_openstack_driver,
mock_patching_client,
mock_sysinv_client):
mock_context.get_admin_context.return_value = self.ctxt
pm = patch_audit.PatchAudit(self.ctxt,
mock_context.get_admin_context.return_value = self.ctx
pm = patch_audit.PatchAudit(self.ctx,
self.fake_dcmanager_state_api)
am = subcloud_audit_manager.SubcloudAuditManager()
am.patch_audit = pm
mock_patching_client.side_effect = FakePatchingClientInSync
mock_sysinv_client.side_effect = FakeSysinvClientOneLoadUpgradeInProgress
self.mock_sysinv_client.side_effect = \
FakeSysinvClientOneLoadUpgradeInProgress
do_load_audit = True
patch_audit_data = self.get_patch_audit_data(am)
subclouds = {base.SUBCLOUD_1['name']: base.SUBCLOUD_1['region_name'],
base.SUBCLOUD_2['name']: base.SUBCLOUD_2['region_name']}
for name, region in subclouds.items():
pm.subcloud_patch_audit(name, region, patch_audit_data, do_load_audit)
for index, subcloud in enumerate(subclouds.keys(), start=2):
subcloud_region = subclouds[subcloud]
pm.subcloud_patch_audit(
self.mock_openstack_driver(),
self.mock_sysinv_client(subcloud_region), f"192.168.1.{index}",
subcloud, subcloud_region, patch_audit_data, do_load_audit
)
expected_calls = [
mock.call(mock.ANY,

116
distributedcloud/dcmanager/tests/unit/audit/test_subcloud_audit_worker_manager.py
View File

@@ -86,6 +86,13 @@ class FakeKubeRootcaUpdateAudit(object):
self.get_regionone_audit_data = mock.MagicMock()
class FakeSoftwareAudit(object):
def __init__(self):
self.subcloud_software_audit = mock.MagicMock()
self.get_regionone_audit_data = mock.MagicMock()
class FakeServiceGroup(object):
def __init__(self, status, desired_state, service_group_name, uuid,
node_name, state, condition, name):
@@ -212,32 +219,6 @@ FAKE_APPLICATIONS = [
]
class FakeSysinvClient(object):
def __init__(self, region, session):
self.get_service_groups_result = FAKE_SERVICE_GROUPS
self.get_applications_result = FAKE_APPLICATIONS
def get_service_groups(self):
return self.get_service_groups_result
def get_applications(self):
return self.get_applications_result
class FakeFmClient(object):
def get_alarm_summary(self):
pass
class FakeOpenStackDriver(object):
def __init__(self, region_name):
self.sysinv_client = FakeSysinvClient('fake_region', 'fake_session')
self.fm_client = FakeFmClient()
class TestAuditWorkerManager(base.DCManagerTestCase):
def setUp(self):
super(TestAuditWorkerManager, self).setUp()
@@ -264,13 +245,6 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
self.mock_audit_worker_api.return_value = self.fake_audit_worker_api
self.addCleanup(p.stop)
# Mock the OpenStackDriver
self.fake_openstack_client = FakeOpenStackDriver('fake_region')
p = mock.patch.object(subcloud_audit_worker_manager, 'OpenStackDriver')
self.mock_openstack_driver = p.start()
self.mock_openstack_driver.return_value = self.fake_openstack_client
self.addCleanup(p.stop)
# Mock the context
p = mock.patch.object(subcloud_audit_worker_manager, 'context')
self.mock_context = p.start()
@@ -361,6 +335,31 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
self.fake_kube_rootca_update_audit2
self.addCleanup(p.stop)
# Mock software audit in Audit Worker and Audit Manager
self.fake_software_audit = FakeSoftwareAudit()
p = mock.patch.object(subcloud_audit_worker_manager, 'software_audit')
self.mock_software_audit = p.start()
self.mock_software_audit.SoftwareAudit.return_value = \
self.fake_software_audit
self.addCleanup(p.stop)
self.fake_software_audit2 = FakeSoftwareAudit()
p = mock.patch.object(subcloud_audit_manager, 'software_audit')
self.mock_software_audit2 = p.start()
self.mock_software_audit2.SoftwareAudit.return_value = \
self.fake_software_audit2
self.addCleanup(p.stop)
self._mock_openstack_driver(subcloud_audit_worker_manager)
self._mock_sysinv_client(subcloud_audit_worker_manager)
self._mock_fm_client(subcloud_audit_worker_manager)
self.mock_fm_client().get_alarm_summary.return_value = None
self.mock_sysinv_client().get_service_groups.return_value = \
FAKE_SERVICE_GROUPS
self.mock_sysinv_client().get_applications.return_value = \
FAKE_APPLICATIONS
@staticmethod
def create_subcloud_static(ctxt, **kwargs):
values = {
@@ -461,23 +460,25 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
# Verify alarm update is called
self.fake_alarm_aggr.update_alarm_summary.assert_called_with(
subcloud.name, self.fake_openstack_client.fm_client)
subcloud.name, self.mock_fm_client())
# Verify patch audit is called
self.fake_patch_audit.subcloud_patch_audit.assert_called_with(
subcloud.name, subcloud.region_name, patch_audit_data, do_load_audit)
mock.ANY, mock.ANY, subcloud.management_start_ip, subcloud.name,
subcloud.region_name, patch_audit_data, do_load_audit)
# Verify firmware audit is called
self.fake_firmware_audit.subcloud_firmware_audit.assert_called_with(
subcloud.name, subcloud.region_name, firmware_audit_data)
mock.ANY, subcloud.name, subcloud.region_name, firmware_audit_data)
# Verify kubernetes audit is called
self.fake_kubernetes_audit.subcloud_kubernetes_audit.assert_called_with(
subcloud.name, subcloud.region_name, kubernetes_audit_data)
mock.ANY, subcloud.name, subcloud.region_name, kubernetes_audit_data)
# Verify kube rootca update audit is called
self.fake_kube_rootca_update_audit.subcloud_kube_rootca_audit.\
assert_called_with(subcloud, kube_rootca_update_audit_data)
assert_called_with(mock.ANY, self.mock_fm_client(), subcloud,
kube_rootca_update_audit_data)
def test_audit_subcloud_online_first_identity_sync_not_complete(self):
@@ -756,10 +757,9 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
availability_status=dccommon_consts.AVAILABILITY_ONLINE)
# Mark a service group as inactive
self.fake_openstack_client.sysinv_client.get_service_groups_result = \
copy.deepcopy(FAKE_SERVICE_GROUPS)
self.fake_openstack_client.sysinv_client. \
get_service_groups_result[3].state = 'inactive'
service_groups = copy.deepcopy(FAKE_SERVICE_GROUPS)
service_groups[3].state = 'inactive'
self.mock_sysinv_client().get_service_groups.return_value = service_groups
# Audit the subcloud
do_patch_audit = True
@@ -798,23 +798,24 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
# Verify alarm update is called once
self.fake_alarm_aggr.update_alarm_summary.assert_called_once_with(
subcloud.name, self.fake_openstack_client.fm_client)
subcloud.name, self.mock_fm_client())
# Verify patch audit is called once
self.fake_patch_audit.subcloud_patch_audit.assert_called_once_with(
mock.ANY, mock.ANY, subcloud.management_start_ip,
subcloud.name, subcloud.region_name, mock.ANY, True)
# Verify firmware audit is called once
self.fake_firmware_audit.subcloud_firmware_audit.assert_called_once_with(
subcloud.name, subcloud.region_name, mock.ANY)
mock.ANY, subcloud.name, subcloud.region_name, mock.ANY)
# Verify kubernetes audit is called once
self.fake_kubernetes_audit.subcloud_kubernetes_audit.assert_called_once_with(
subcloud.name, subcloud.region_name, mock.ANY)
mock.ANY, subcloud.name, subcloud.region_name, mock.ANY)
# Verify kube rootca update audit is called once
self.fake_kube_rootca_update_audit.subcloud_kube_rootca_audit.\
assert_called_once_with(subcloud, mock.ANY)
assert_called_once_with(mock.ANY, mock.ANY, subcloud, mock.ANY)
# Verify the audit fail count was updated in db
audit_fail_count = 1
@@ -882,10 +883,9 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
self.ctx, subcloud.id, audit_fail_count=consts.AVAIL_FAIL_COUNT_MAX)
# Mark a service group as inactive
self.fake_openstack_client.sysinv_client.get_service_groups_result = \
copy.deepcopy(FAKE_SERVICE_GROUPS)
self.fake_openstack_client.sysinv_client. \
get_service_groups_result[3].state = 'inactive'
service_groups = copy.deepcopy(FAKE_SERVICE_GROUPS)
service_groups[3].state = 'inactive'
self.mock_sysinv_client().get_service_groups.return_value = service_groups
# Audit the subcloud
do_patch_audit = True
@@ -1058,10 +1058,9 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
self.ctx, subcloud.id, audit_fail_count=audit_fail_count)
# Mark a service group as inactive
self.fake_openstack_client.sysinv_client.get_service_groups_result = \
copy.deepcopy(FAKE_SERVICE_GROUPS)
self.fake_openstack_client.sysinv_client. \
get_service_groups_result[3].state = 'inactive'
service_groups = copy.deepcopy(FAKE_SERVICE_GROUPS)
service_groups[3].state = 'inactive'
self.mock_sysinv_client().get_service_groups.return_value = service_groups
# Audit the subcloud
do_patch_audit = True
@@ -1191,7 +1190,7 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
# Verify alarm update is called
self.fake_alarm_aggr.update_alarm_summary.assert_called_once_with(
'subcloud1', self.fake_openstack_client.fm_client)
'subcloud1', self.mock_fm_client())
# Verify patch audit is not called
self.fake_patch_audit.subcloud_patch_audit.assert_not_called()
@@ -1256,7 +1255,7 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
# Verify alarm update is called
self.fake_alarm_aggr.update_alarm_summary.assert_called_once_with(
subcloud.name, self.fake_openstack_client.fm_client)
subcloud.name, self.mock_fm_client())
# Verify patch audit is not called
self.fake_patch_audit.subcloud_patch_audit.assert_not_called()
@@ -1321,7 +1320,7 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
# Verify alarm update is called
self.fake_alarm_aggr.update_alarm_summary.assert_called_once_with(
'subcloud1', self.fake_openstack_client.fm_client)
'subcloud1', self.mock_fm_client())
# Verify patch audit is not called
self.fake_patch_audit.subcloud_patch_audit.assert_not_called()
@@ -1400,7 +1399,8 @@ class TestAuditWorkerManager(base.DCManagerTestCase):
do_software_audit)
# Verify patch audit is called
self.fake_patch_audit.subcloud_patch_audit.assert_called_with(
self.fake_patch_audit.subcloud_patch_audit.assert_called_once_with(
mock.ANY, mock.ANY, subcloud.management_start_ip,
subcloud.name, subcloud.region_name, patch_audit_data, do_load_audit)
# Verify the _update_subcloud_audit_fail_count is not called