utf-queue-client 1.15.2__tar.gz → 1.17.2__tar.gz

utf-queue-client-1.17.2/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.1
+Name: utf-queue-client
+Version: 1.17.2
+Home-page: 
+Author: Joe Savage
+Author-email: joe.savage@silabs.com
+Keywords: UTF,
+Requires-Python: >=3.6
+
+    No description provided
+    

{utf-queue-client-1.15.2 → utf-queue-client-1.17.2}/setup.py

@@ -2,11 +2,10 @@
 
 """
 
-
 from setuptools import setup, find_packages  # noqa: H301
 
 NAME = "utf-queue-client"
-VERSION = "1.15.2"
+VERSION = "1.17.2"
 # To install the library, run the following
 #
 # python setup.py install
@@ -54,7 +53,7 @@ setup(
             "publish_test_results_cli = utf_queue_client.scripts.publish_test_results_cli:cli_entrypoint",
             "ubai_update_retention_cli = utf_queue_client.scripts.ubai_update_retention_cli:cli_entrypoint",
             "publish_release_info_cli = utf_queue_client.scripts.publish_release_info_cli:cli_entrypoint",
-            "ubai_copy_cli = utf_queue_client.scripts.ubai_copy_cli:cli_entrypoint"
+            "ubai_copy_cli = utf_queue_client.scripts.ubai_copy_cli:cli_entrypoint",
         ],
     },
     include_package_data=True,

utf-queue-client-1.17.2/test/test_amqp_connections.py

@@ -0,0 +1,46 @@
+import os
+from utf_queue_client.clients.base_producer import BlockingProducer
+import pytest
+import logging
+import pika
+import time
+from utf_queue_client.utils import UTF_QUEUE_REGION_MAP
+from urllib.parse import quote
+
+
+regions = list(UTF_QUEUE_REGION_MAP.values())
+servers = [f"utf-queue-{region}" for region in regions]
+
+
+@pytest.fixture(params=servers)
+def queue_server(request):
+    yield request.param
+
+
+@pytest.mark.parametrize(
+    "username, password",
+    [
+        (os.environ["UTF_QUEUE_USERNAME_LDAP"], os.environ["UTF_QUEUE_PASSWORD_LDAP"]),
+        (os.environ["UTF_QUEUE_USERNAME"], os.environ["UTF_QUEUE_PASSWORD"]),
+    ],
+)
+def test_producer(queue_server, username, password):
+    suffix = ".silabs.net"
+    queue_server = f"{queue_server}{suffix}"
+    l = logging.getLogger("test_producer")
+    l.info("Creating producer...")
+    p = BlockingProducer(
+        url=f"amqps://{username}:{quote(password)}@{queue_server}:443/testing?stack_timeout=30",
+    )
+    l.info(f"{queue_server}: Created producer")
+    params = pika.URLParameters(p.url)
+    l.info(f"stack timeout: {params.stack_timeout}")
+    begin = time.time()
+    for _ in range(0, 10):
+        l.info(f"{queue_server}: declaring queue...")
+        start = time.time()
+        p.queue_declare("default", durable=True)
+        stop = time.time()
+        l.info(
+            f"{queue_server}: done declaring queue in {stop - start} sec.  Total time: {stop - begin}"
+        )

utf-queue-client-1.17.2/test/test_http_producer.py

@@ -0,0 +1,90 @@
+import pytest
+from utf_queue_client.clients.base_producer import (
+    ConnectionError as QueueServerConnectionError,
+)
+from utf_queue_client.clients.http_producer import (
+    HTTPProducer,
+    HTTPChannel,
+    CompositeHTTPProducer,
+)
+from pika.spec import BasicProperties, PERSISTENT_DELIVERY_MODE
+from unittest.mock import patch
+import utf_queue_client.clients.http_producer
+
+FAKE_CREDS = "notarealusername:notarealpassword"
+
+
+def test_basic_properties_to_json():
+    assert HTTPChannel.basic_properties_to_json(BasicProperties(app_id="foo")) == {
+        "app_id": "foo"
+    }
+    assert HTTPChannel.basic_properties_to_json(
+        BasicProperties(app_id="foo", delivery_mode=PERSISTENT_DELIVERY_MODE)
+    ) == {"app_id": "foo", "delivery_mode": 2}
+    assert HTTPChannel.basic_properties_to_json(None) == {}
+
+
+def test_http_channel_connection_error():
+    channel = HTTPChannel(
+        "https://localshmost", ("user", "pass"), "/", retries=0, retry_delay=0
+    )
+    with pytest.raises(QueueServerConnectionError):
+        channel.queue_declare("queue")
+    with pytest.raises(QueueServerConnectionError):
+        channel.basic_publish("exchange", "routing_key", b"foo", None)
+
+
+def test_composite_producer_errors():
+    with patch.object(
+        utf_queue_client.clients.http_producer, "DEFAULT_NUM_CONNECTION_RETRIES", 0
+    ):
+        composite_producer = CompositeHTTPProducer(
+            f"amqps://{FAKE_CREDS}@localshmost:443/%2F", "app_id"
+        )
+        composite_producer.producers.append(composite_producer.producers[0])
+        with pytest.raises(QueueServerConnectionError):
+            composite_producer.queue_declare("queue")
+        with pytest.raises(QueueServerConnectionError):
+            composite_producer.publish("exchange", "routing_key", {"foo": "bar"}, True)
+
+
+@pytest.mark.parametrize(
+    ("amqp_url", "expected_http_urls"),
+    [
+        (
+            f"amqps://{FAKE_CREDS}@localshmost:443/%2F",
+            ["https://localshmost-admin:443"],
+        ),
+        (
+            f"amqps://{FAKE_CREDS}@utf-queue-central:443/%2F",
+            ["https://utf-queue-central-admin:443"],
+        ),
+        (
+            f"amqps://{FAKE_CREDS}@utf-queue-central.silabs.net:443/%2F",
+            [
+                "https://utf-queue-central-admin.silabs.net:443",
+                "https://utf-queue-aus-admin.silabs.net:443",
+                "https://utf-queue-bos-admin.silabs.net:443",
+                "https://utf-queue-bud-admin.silabs.net:443",
+                "https://utf-queue-hyd-admin.silabs.net:443",
+                "https://utf-queue-yul-admin.silabs.net:443",
+            ],
+        ),
+        (
+            f"amqps://{FAKE_CREDS}@utf-queue-aus.silabs.net:443/%2F",
+            [
+                "https://utf-queue-central-admin.silabs.net:443",
+                "https://utf-queue-aus-admin.silabs.net:443",
+                "https://utf-queue-bos-admin.silabs.net:443",
+                "https://utf-queue-bud-admin.silabs.net:443",
+                "https://utf-queue-hyd-admin.silabs.net:443",
+                "https://utf-queue-yul-admin.silabs.net:443",
+            ],
+        ),
+    ],
+)
+def test_composite_producer_creation(amqp_url, expected_http_urls):
+    composite_producer = CompositeHTTPProducer(amqp_url, "app_id")
+    assert len(composite_producer.producers) == len(expected_http_urls)
+    for index, value in enumerate(expected_http_urls):
+        assert composite_producer.producers[index].channel.url == value

utf-queue-client-1.17.2/test/test_publish_release_info.py

@@ -0,0 +1,145 @@
+import pytest
+from otel_extensions import inject_context_to_env, instrumented
+import os
+import subprocess
+import sys
+from utf_queue_client.scripts.publish_release_info_cli import publish_release_information, \
+    update_artifacts_retention_days_to_keep_forever, cli
+import requests
+from unittest import mock
+from unittest.mock import MagicMock, patch
+
+
+@pytest.fixture
+def publish_release_info():
+    yield [
+        ("releaseDate", "2023-06-16"),
+        ("branchName", "release/gecko_sdk_3.2"),
+        ("releaseType", "GA"),
+        ("releaseName", "23Q2-GA"),
+        ("SDKBuildNum", "407"),
+        ("installerURLSDK", "https://jenkins-cbs-gecko-sdk.silabs.net/job/Gecko_SDK_Suite_super/job/release%252F21q4/284/"),
+        ("IARVersionNum", "9.20.4"),
+        ("GCCVersionNum", "10.3.1"),
+        ("CommanderVersionNum", "v1.8.1"),
+        ("SEVersionNum", "1.2.4"),
+        ("WSTKFirmwareVersionNum", "v1.4.4")
+    ]
+
+
+@instrumented
+def test_publish_release_info(request, publish_release_info):
+    args = ["--username", "svc_sqabot", "--password", "password"]
+    for k, v in publish_release_info:
+        args += ["--data", k, v]
+
+    base_dir = os.path.dirname(os.path.dirname(__file__))
+    @inject_context_to_env
+    def call_cli_script():
+        assert "TRACEPARENT" in os.environ
+        process = subprocess.Popen(
+            [
+                sys.executable,
+                os.path.join(
+                    base_dir, "utf_queue_client", "scripts", "publish_release_info_cli.py"
+                ),
+            ]
+            + args,
+        )
+        process.communicate()
+        assert process.poll() == 0
+
+    call_cli_script()
+
+
+def test_publish_release_information():
+    requests_post = requests.post
+    requests.post = MagicMock()
+    publish_release_information("", "", {})
+    assert requests.post.call_count == 2
+    requests.post = requests_post
+
+
+def test_publish_release_cli_insufficient_params():
+    requests_post = requests.post
+    requests_post_mock = MagicMock()
+    requests.post = requests_post_mock
+    cli("", "", {})
+    assert requests.post.call_count == 0
+    requests.post = requests_post
+
+
+def test_publish_release_cli():
+    requests_post = requests.post
+    requests_post_mock = MagicMock()
+    requests.post = requests_post_mock
+    cli("", "", {("branchName", "test"), ("releaseData", "")})
+    assert requests_post_mock.call_count == 2
+    post_params = requests_post_mock.call_args.kwargs.get('json')
+    assert post_params.get("branchName") == "test"
+    assert post_params.get("releaseData") is None
+    requests.post = requests_post
+
+
+def test_update_artifacts_retention_days_to_keep_forever():
+    requests_patch = requests.patch
+    requests.patch = MagicMock()
+    data_dict = {"branchName": "release/gec", "SDKBuildNum": "407"}
+    update_artifacts_retention_days_to_keep_forever(data_dict)
+    assert requests.patch.call_count == 1
+    requests.patch = requests_patch
+    patch_response = MagicMock()
+    mocked_patch =mock.patch.object(requests, "patch", return_value=patch_response)
+    patch_response.status_code = 200
+    update_artifacts_retention_days_to_keep_forever(data_dict)
+
+
+@patch('requests.post')
+def test_publish_release_information_success(mock_post):
+    mock_response_auth = MagicMock()
+    mock_response_auth.json.return_value = {"access_token": "test_token"}
+    mock_response_auth.raise_for_status.return_value = None
+
+    mock_response_release = MagicMock()
+    mock_response_release.status_code = 201
+    mock_response_release.json.return_value = {"message": "success"}
+
+    mock_post.side_effect = [mock_response_auth, mock_response_release]
+
+    result = publish_release_information("test_username", "test_password", {"test_key": "test_value"})
+    assert mock_response_release.json.called
+    assert result
+
+@patch('requests.post')
+def test_publish_release_information_release_fail(mock_post):
+    # Mock the responses
+    mock_response_auth = MagicMock()
+    mock_response_auth.json.return_value = {"access_token": "test_token"}
+    mock_response_auth.raise_for_status.return_value = None
+
+    mock_response_release = MagicMock()
+    mock_response_release.status_code = 400
+    mock_response_release.text = "Release failed"
+
+    mock_post.side_effect = [mock_response_auth, mock_response_release]
+
+    result = publish_release_information("test_username", "test_password", {"test_key": "test_value"})
+    assert result is None
+
+@patch('requests.post')
+def test_publish_release_information_release_fail_422(mock_post):
+    # Mock the responses
+    mock_response_auth = MagicMock()
+    mock_response_auth.json.return_value = {"access_token": "test_token"}
+    mock_response_auth.raise_for_status.return_value = None
+
+    mock_response_release = MagicMock()
+    mock_response_release.status_code = 422
+    mock_response_release.json.return_value = {"detail": [{"loc": ["", "test_field"], "msg": "test_error"}]}
+
+    mock_post.side_effect = [mock_response_auth, mock_response_release]
+
+    # Call the function
+    result = publish_release_information("test_username", "test_password", {"test_key": "test_value"})
+    assert mock_response_release.json.called
+    assert result is None

utf-queue-client-1.17.2/test/test_rail_data_producer_tests.py

@@ -0,0 +1,64 @@
+from unittest.mock import MagicMock
+
+from utf_queue_client.clients.test_rail_data_producer import (
+    TestRailDataProducer,
+    TestRailDataProducerFactory,
+    DummyTestRailDataProducer,
+    LocalTestRailDataProducer,
+)
+import pytest
+import os
+
+
+def test_result_producer_empty_url():
+    with pytest.raises(RuntimeError):
+        _ = TestRailDataProducer()
+
+
+@pytest.mark.parametrize("queue_consumer", [60, 120], indirect=True)
+def test_result_producer_central_queue(
+    request,
+    test_rail_add_test_result,
+    amqp_url,
+    queue_consumer,
+):
+    os.environ["UTF_PRODUCER_APP_ID"] = request.node.name
+    producer = TestRailDataProducerFactory.create_producer()
+    producer.publish_add_test_result(test_rail_add_test_result)
+    queue_consumer.expect_messages(1)
+
+
+def test_dummy_producer(test_rail_add_test_result):
+    producer = DummyTestRailDataProducer()
+    producer.publish_add_test_result(test_rail_add_test_result)
+
+
+def test_local_test_rail_producer(test_rail_add_test_result, mocker):
+    mocker.patch(
+        "utf_queue_client.clients.base_producer.BlockingProducer.__init__",
+        return_value=None,
+    )
+    mocker.patch(
+        "utf_queue_client.clients.base_producer.BlockingProducer.queue_declare"
+    )
+    mock_producer_publish = mocker.patch(
+        "utf_queue_client.clients.base_producer.BlockingProducer.publish"
+    )
+    producer = LocalTestRailDataProducer()
+    producer.producer_app_id = "DUMMY"
+    producer.publish_add_test_result(test_rail_add_test_result)
+    assert mock_producer_publish.called
+    kwargs = mock_producer_publish.call_args.kwargs
+    payload = kwargs.get("payload")
+    assert payload.get("recordType") == "TEST_RAIL_EVENT"
+    assert payload.get("recordSubType") == "TEST_RESULT"
+    assert payload.get("tenantKey") == "DUMMY"
+    payload_data = payload.get("payload")
+    assert payload_data.get("version") == "v1"
+    assert payload_data.get("comment") == "testing"
+    assert payload_data.get("status") == "pass"
+    assert payload_data.get("run_id") == 1234
+    assert payload_data.get("id") == "C123"
+    custom_props = payload_data.get("custom_props")
+    assert custom_props.get("custom_interface_type") == "gcc"
+    assert custom_props.get("custom_evk_version") == "v2"

{utf-queue-client-1.15.2 → utf-queue-client-1.17.2}/test/test_sqa_test_result_producer.py

@@ -15,6 +15,7 @@ def test_result_producer_empty_url():
 
 
 @pytest.mark.parametrize("queue_consumer", [60, 120], indirect=True)
+@pytest.mark.parametrize("use_http_producer", [True, False])
 def test_result_producer_central_queue(
     request,
     sqa_app_build_result,
@@ -22,9 +23,13 @@ def test_result_producer_central_queue(
     sqa_test_session,
     amqp_url,
     queue_consumer,
+    use_http_producer,
 ):
     os.environ["UTF_PRODUCER_APP_ID"] = request.node.name
-    producer = SqaTestResultProducerFactory.create_producer()
+    os.environ["UTF_QUEUE_USE_HTTP_PRODUCER"] = "true" if use_http_producer else "false"
+    producer = SqaTestResultProducerFactory.create_producer(
+        use_http_producer=use_http_producer
+    )
     producer.publish_app_build_result(sqa_app_build_result)
     queue_consumer.expect_messages(1)
     producer.publish_test_session_start(sqa_test_session)

utf-queue-client-1.17.2/test/test_utils.py

@@ -0,0 +1,77 @@
+import os
+import pytest
+from utf_queue_client.utils import (
+    get_queue_url_list,
+    UTF_QUEUE_REGION_MAP,
+    get_closest_queue_region,
+)
+
+
+NOMAD_DC_PARAMS = [
+    ("NOMAD_DC", value)
+    for value in [
+        None,
+        "aws-us-east-1",
+        "vmw-us-aus-1",
+        "vmw-us-bos-1",
+        "vmw-eu-bud-1",
+        "vmw-ap-hyd-1",
+        "vmw-ca-yul-1",
+        "vmw-ap-syd-1",
+    ]
+]
+FAKE_CREDS = "notarealusername:notarealpassword"
+
+
+@pytest.mark.parametrize(
+    "set_environment_variable",
+    NOMAD_DC_PARAMS,
+    indirect=True,
+)
+@pytest.mark.parametrize("domain", ["dev.silabs.net", "silabs.net"])
+def test_get_queue_url_list(set_environment_variable, domain):
+    nomad_dc = os.getenv("NOMAD_DC")
+    url = f"amqps://{FAKE_CREDS}@utf-queue-central.{domain}:443/%2F?stack_timeout=30"
+    urls = get_queue_url_list(url)
+    assert len(urls) == 6
+
+    region_list = list(UTF_QUEUE_REGION_MAP.values())
+    if nomad_dc is None or nomad_dc not in UTF_QUEUE_REGION_MAP:
+        assert urls[0] == url
+        region_list.remove("central")
+    else:
+        region = UTF_QUEUE_REGION_MAP[nomad_dc]
+        assert urls[0] == url.replace("utf-queue-central", f"utf-queue-{region}")
+        region_list.remove(region)
+    assert urls[1:] == [
+        url.replace("utf-queue-central", f"utf-queue-{region}")
+        for region in region_list
+    ]
+
+
+def test_get_queue_url_list_no_match():
+    url_list = [
+        f"amqps://{FAKE_CREDS}@custom-server.silabs.net:443/%2F?stack_timeout=30",
+        f"amqp://{FAKE_CREDS}@utf-queue-central.silabs.net:5672/%2F",
+        f"amqps://{FAKE_CREDS}@utf-queue-central.silabs.net:5672/%2F",
+        f"amqps://{FAKE_CREDS}@utf-queue-central.silabs.com:443/%2F",
+    ]
+    for url in url_list:
+        urls = get_queue_url_list(url)
+        assert urls == [url]
+
+
+@pytest.mark.parametrize(
+    "set_environment_variable",
+    NOMAD_DC_PARAMS,
+    indirect=True,
+)
+def test_get_closest_queue_region(set_environment_variable):
+    nomad_dc = os.getenv("NOMAD_DC")
+    try:
+        if nomad_dc is None or nomad_dc not in UTF_QUEUE_REGION_MAP:
+            assert get_closest_queue_region() == "central"
+        else:
+            assert get_closest_queue_region() == UTF_QUEUE_REGION_MAP[nomad_dc]
+    finally:
+        os.environ.pop("NOMAD_DC", None)

utf-queue-client-1.17.2/utf_queue_client/clients/http_producer.py

@@ -0,0 +1,207 @@
+import pika
+from pika.spec import BasicProperties
+from typing import Optional, Tuple
+
+from utf_queue_client.clients.base_producer import (
+    BaseProducer,
+    PikaChannel,
+    ConnectionError,
+)
+import base64
+from utf_queue_client.utils import get_queue_url_list
+from requests import Session as RequestsSession, RequestException
+from requests.adapters import HTTPAdapter
+from urllib3.util import Retry
+from . import Loggable
+from dataclasses import dataclass
+from urllib.parse import urlparse
+
+__all__ = ["HTTPProducer", "HTTPChannel", "CompositeHTTPProducer"]
+
+DEFAULT_NUM_CONNECTION_RETRIES = 6
+DEFAULT_CONNECTION_RETRY_DELAY = 10
+
+
+@dataclass
+class UrlInfo:
+    amqp_url: str
+    http_url: str
+    virtual_host: str
+    username: str
+    password: str
+
+
+class HTTPChannel(PikaChannel):
+    def __init__(
+        self,
+        url: str,
+        credentials: Tuple[str, str],
+        virtual_host: str,
+        retries=None,
+        retry_delay=None,
+    ):
+        if retries is None:
+            retries = DEFAULT_NUM_CONNECTION_RETRIES
+        if retry_delay is None:
+            retry_delay = DEFAULT_CONNECTION_RETRY_DELAY
+        self.client = RequestsSession()
+        self.client.verify = False
+        self.client.auth = credentials
+        self.client.mount(
+            "https://",
+            HTTPAdapter(
+                max_retries=Retry(
+                    total=retries,
+                    backoff_factor=retry_delay,
+                    status_forcelist=[404, 429, 500, 502, 503, 504],
+                )
+            ),
+        )
+        self.url = url
+        self.virtual_host = virtual_host
+        if self.virtual_host == "/":
+            self.virtual_host = "%2F"
+
+    @classmethod
+    def basic_properties_to_json(cls, properties: Optional[BasicProperties]) -> dict:
+        props_json = {}
+        if properties:
+            for key in [
+                "app_id",
+                "content_type",
+                "content_encoding",
+                "correlation_id",
+                "cluster_id",
+                "delivery_mode",
+                "expiration",
+                "headers",
+                "message_id",
+                "priority",
+                "reply_to",
+                "timestamp",
+                "type",
+                "user_id",
+            ]:
+                val = getattr(properties, key)
+                if val is not None:
+                    props_json[key] = val
+        return props_json
+
+    def basic_publish(
+        self,
+        exchange: str,
+        routing_key: str,
+        body: bytes,
+        properties: Optional[BasicProperties] = None,
+        mandatory: bool = False,
+    ):
+        if not exchange:
+            exchange = "amq.default"
+        publish_url = f"{self.url}/api/exchanges/{self.virtual_host}/{exchange}/publish"
+        try:
+            r = self.client.post(
+                publish_url,
+                json={
+                    "properties": self.basic_properties_to_json(properties),
+                    "routing_key": routing_key,
+                    "payload": base64.b64encode(body).decode("utf-8"),
+                    "payload_encoding": "base64",
+                },
+            )
+            r.raise_for_status()
+        except RequestException as e:
+            raise ConnectionError(e)
+
+    def queue_declare(
+        self,
+        queue,
+        passive=False,
+        durable=False,
+        exclusive=False,
+        auto_delete=False,
+        arguments=None,
+        callback=None,
+    ):
+        declare_url = f"{self.url}/api/queues/{self.virtual_host}/{queue}"
+        try:
+            r = self.client.put(
+                declare_url, json={"auto_delete": auto_delete, "durable": durable}
+            )
+            r.raise_for_status()
+        except RequestException as e:
+            raise ConnectionError(e)
+
+
+class HTTPProducer(BaseProducer):
+    def __init__(
+        self,
+        url_info: UrlInfo,
+        producer_app_id: Optional[str] = None,
+    ):
+        super().__init__(url_info.amqp_url, producer_app_id)
+        self._channel = HTTPChannel(
+            url_info.http_url,
+            (url_info.username, url_info.password),
+            url_info.virtual_host,
+        )
+        self.hostname = urlparse(url_info.http_url).hostname
+
+    def _connect(self):
+        # no long-lived connection
+        pass
+
+    def is_connected(self):
+        return True  # pragma: nocover
+
+    @property
+    def channel(self) -> HTTPChannel:
+        return self._channel
+
+
+class CompositeHTTPProducer(Loggable):
+    def __init__(self, url: str, producer_app_id: str = None):
+        url_list = get_queue_url_list(url)
+        self.producers = [
+            HTTPProducer(self.convert_amqp_url_to_http_url(alt_url), producer_app_id)
+            for alt_url in url_list
+        ]
+
+    @classmethod
+    def convert_amqp_url_to_http_url(cls, amqp_url: str) -> UrlInfo:
+        url_params = pika.URLParameters(amqp_url)
+        host, delim, domain = url_params.host.partition(".")
+        hostname = f"{host}-admin{delim}{domain}:{url_params.port}"
+        scheme = "https" if url_params.ssl_options else "http"
+        return UrlInfo(
+            amqp_url=amqp_url,
+            http_url=f"{scheme}://{hostname}",
+            virtual_host=url_params.virtual_host,
+            username=url_params.credentials.username,
+            password=url_params.credentials.password,
+        )
+
+    def queue_declare(self, queue, **kwargs):
+        for index, producer in enumerate(self.producers):
+            if index:
+                self.logger.warning(
+                    f"Failed to execute queue_declare for host {self.producers[index-1].hostname}, retrying with {producer.hostname}..."
+                )
+            try:
+                return producer.queue_declare(queue, **kwargs)
+            except ConnectionError:
+                if index == len(self.producers) - 1:
+                    raise
+                continue
+
+    def publish(self, exchange: str, routing_key: str, payload: dict, persistent: bool):
+        for index, producer in enumerate(self.producers):
+            if index:
+                self.logger.warning(
+                    f"Failed to execute publish for host {self.producers[index-1].hostname}, retrying with {producer.hostname}..."
+                )
+            try:
+                return producer.publish(exchange, routing_key, payload, persistent)
+            except ConnectionError:
+                if index == len(self.producers) - 1:
+                    raise
+                continue