utf-queue-client 1.15.1__tar.gz → 1.16.0__tar.gz

{utf-queue-client-1.15.1 → utf-queue-client-1.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.2
 Name: utf-queue-client
-Version: 1.15.1
+Version: 1.16.0
 Summary: UNKNOWN
 Home-page: UNKNOWN
 Author: Joe Savage

{utf-queue-client-1.15.1 → utf-queue-client-1.16.0}/setup.py

@@ -6,7 +6,7 @@
 from setuptools import setup, find_packages  # noqa: H301
 
 NAME = "utf-queue-client"
-VERSION = "1.15.1"
+VERSION = "1.16.0"
 # To install the library, run the following
 #
 # python setup.py install

utf-queue-client-1.16.0/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 = ".dev.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.16.0/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.15.1 → utf-queue-client-1.16.0}/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.16.0/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.16.0/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

{utf-queue-client-1.15.1 → utf-queue-client-1.16.0}/utf_queue_client/clients/sqa_test_result_producer.py

@@ -1,6 +1,8 @@
 import os
-
-from .base_producer import BlockingProducer, ConnectionError
+import re
+from .base_producer import BlockingProducer as AMQPBlockingProducer, ConnectionError
+from .http_producer import CompositeHTTPProducer
+from ..utils import UTF_QUEUE_SERVER_PATTERN
 from ..models import SqaAppBuildResult
 from ..models import SqaTestResult
 from ..models import SqaTestSession
@@ -10,6 +12,8 @@ from socket import gethostname
 from datetime import datetime
 from abc import ABC, abstractmethod
 from otel_extensions import instrumented
+from typing import Optional
+
 
 __all__ = [
     "SqaTestResultProducer",
@@ -43,9 +47,16 @@ class BaseSqaTestResultProducer(ABC):
 class SqaTestResultProducer(BaseSqaTestResultProducer):
     RECORD_TYPE = "UTF_TEST_EVENT"
 
-    def __init__(self, url=None, producer_app_id: str = None):
+    def __init__(
+        self,
+        url=None,
+        producer_app_id: str = None,
+        producer_class: Optional[type] = None,
+    ):
+        if producer_class is None:
+            producer_class = AMQPBlockingProducer
         self.queue_name = "default"
-        self.__client = BlockingProducer(url, producer_app_id)
+        self.__client = producer_class(url, producer_app_id)
         self.__client.queue_declare(queue=self.queue_name, durable=True)
         self.producer_app_id = producer_app_id
 
@@ -136,13 +147,20 @@ class DummySqaTestResultProducer(BaseSqaTestResultProducer):
 
 class SqaTestResultProducerFactory(Loggable):
     @classmethod
-    def create_producer(cls, raise_on_connection_error=False):
+    def create_producer(cls, raise_on_connection_error=False, use_http_producer=True):
         try:
             queue_server_url = os.environ.get("UTF_QUEUE_SERVER_URL")
             if queue_server_url is not None:
+                producer_class = None
+                use_http_producer = use_http_producer and os.environ.get("UTF_QUEUE_USE_HTTP_PRODUCER") == "true"
+                if use_http_producer and re.match(
+                    UTF_QUEUE_SERVER_PATTERN, queue_server_url
+                ):
+                    producer_class = CompositeHTTPProducer
                 return SqaTestResultProducer(
                     url=queue_server_url,
                     producer_app_id=os.environ.get("UTF_PRODUCER_APP_ID"),
+                    producer_class=producer_class,
                 )
             else:
                 return LocalSqaTestResultProducer()

utf-queue-client-1.16.0/utf_queue_client/utils/__init__.py

@@ -0,0 +1,89 @@
+import os
+from urllib import parse
+from typing import List
+import re
+
+QUEUE_APP_ID = "app_queue_client"
+UTF_QUEUE_REGION_MAP = {
+    "aws-us-east-1": "central",
+    "vmw-us-aus-1": "aus",
+    "vmw-us-bos-1": "bos",
+    "vmw-eu-bud-1": "bud",
+    "vmw-ap-hyd-1": "hyd",
+    "vmw-ca-yul-1": "yul",
+}
+UTF_QUEUE_SERVER_PREFIX = "utf-queue-"
+UTF_QUEUE_SERVER_PATTERN = (
+    "amqps://(.*):(.*)@"
+    + rf"({UTF_QUEUE_SERVER_PREFIX}({'|'.join(UTF_QUEUE_REGION_MAP.values())}))"
+    + r"\.(dev\.silabs\.net|silabs\.net):443"
+)
+
+
+def prepare_queue_central_url(username, password):
+    if username is None or password is None:
+        raise RuntimeError("username or password must be provided if using queue")
+    hostname = os.environ.get("UTF_QUEUE_HOSTNAME", "utf-queue-central.silabs.net")
+    scheme = os.environ.get("UTF_QUEUE_SCHEME", "amqps")
+    port = os.environ.get("UTF_QUEUE_PORT", "443")
+    virtual_host = os.environ.get("UTF_QUEUE_VIRTUAL_HOST", "%2f")
+    return f"{scheme}://{username}:{parse.quote(password)}@{hostname}:{port}/{virtual_host}"
+
+
+def get_closest_queue_region():
+    """
+    Return the correct value from the UTF_QUEUE_REGION_MAP dictionary
+    based on the key contained in the NOMAD_DC environment variable (if it's defined).
+    If NOMAD_DC is not defined or the key is not in UTF_QUEUE_REGION_MAP, we'll just
+    return "central"
+    """
+    if "NOMAD_DC" in os.environ:
+        dc = os.environ["NOMAD_DC"]
+        if dc in UTF_QUEUE_REGION_MAP:
+            return UTF_QUEUE_REGION_MAP[dc]
+
+    return "central"
+
+
+def get_queue_url_list(original_url: str) -> List[str]:
+    """
+    The purpose of this function is to return a list of alternative
+    utf queue urls given a single original url.
+    If 'original_url' matches the UTF_QUEUE_SERVER_PATTERN regex,
+    return a list of urls based on the values in the UTF_QUEUE_REGION_MAP dict,
+    where the order is determined by the NOMAD_DC environment variable.
+
+    Example:
+    1)  if original_url is "amqps://xxxx:yyyy@utf-queue-central.silabs.net:443/%2F"
+        and NOMAD_DC is "vmw-ap-hyd-1",
+        we'll return
+        - amqps://xxxx:yyyy@utf-queue-hyd.silabs.net:443/%2F
+        - amqps://xxxx:yyyy@utf-queue-central.silabs.net:443/%2F
+        - amqps://xxxx:yyyy@utf-queue-aus.silabs.net:443/%2F
+        - amqps://xxxx:yyyy@utf-queue-bos.silabs.net:443/%2F
+          etc.
+    2) if original_url is "amqps://xxxx:yyyy@utf-queue-central.silabs.net:443/%2F"
+        and NOMAD_DC is not defined,
+        we'll return
+        - amqps://xxxx:yyyy@utf-queue-central.silabs.net:443/%2F
+        - amqps://xxxx:yyyy@utf-queue-aus.silabs.net:443/%2F
+        - amqps://xxxx:yyyy@utf-queue-bos.silabs.net:443/%2F
+          etc.
+    3) if original_url doesn't match the UTF_QUEUE_SERVER_PATTERN pattern
+       we'll return a list containing original_url as the only item.
+    """
+    m = re.match(UTF_QUEUE_SERVER_PATTERN, original_url)
+    if not m:
+        return [original_url]
+
+    hostname_base = m.group(3)
+    domain = m.group(5)
+
+    url_list = []
+    region_list = [get_closest_queue_region()] + list(UTF_QUEUE_REGION_MAP.values())
+    for region in region_list:
+        url = original_url.replace(
+            f"{hostname_base}.{domain}", f"{UTF_QUEUE_SERVER_PREFIX}{region}.{domain}"
+        )
+        url_list.append(url)
+    return list(dict.fromkeys(url_list))

{utf-queue-client-1.15.1 → utf-queue-client-1.16.0}/utf_queue_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.2
 Name: utf-queue-client
-Version: 1.15.1
+Version: 1.16.0
 Summary: UNKNOWN
 Home-page: UNKNOWN
 Author: Joe Savage

{utf-queue-client-1.15.1 → utf-queue-client-1.16.0}/utf_queue_client.egg-info/SOURCES.txt

@@ -1,9 +1,11 @@
 README.md
 setup.cfg
 setup.py
+test/test_amqp_connections.py
 test/test_async_consumer.py
 test/test_connection_retry.py
 test/test_data_lake_data_producer.py
+test/test_http_producer.py
 test/test_legacy_base_model.py
 test/test_models.py
 test/test_opentelemetry_data_producer.py
@@ -14,6 +16,7 @@ test/test_ubai_copy.py
 test/test_ubai_search.py
 test/test_ubai_update_retention.py
 test/test_ubai_upload.py
+test/test_utils.py
 utf_queue_client/__init__.py
 utf_queue_client.egg-info/PKG-INFO
 utf_queue_client.egg-info/SOURCES.txt
@@ -25,6 +28,7 @@ utf_queue_client/clients/__init__.py
 utf_queue_client/clients/async_consumer.py
 utf_queue_client/clients/base_producer.py
 utf_queue_client/clients/data_lake_data_producer.py
+utf_queue_client/clients/http_producer.py
 utf_queue_client/clients/opentelemetry_data_producer.py
 utf_queue_client/clients/sqa_test_result_producer.py
 utf_queue_client/clients/ubai_artifact_upload_request_producer.py

utf-queue-client-1.15.1/utf_queue_client/utils/__init__.py

@@ -1,14 +0,0 @@
-import os
-from urllib import parse
-
-QUEUE_APP_ID = "app_queue_client"
-
-
-def prepare_queue_central_url(username, password):
-    if username is None or password is None:
-        raise RuntimeError("username or password must be provided if using queue")
-    hostname = os.environ.get("UTF_QUEUE_HOSTNAME", "utf-queue-central.silabs.net")
-    scheme = os.environ.get("UTF_QUEUE_SCHEME", "amqps")
-    port = os.environ.get("UTF_QUEUE_PORT", "443")
-    virtual_host = os.environ.get("UTF_QUEUE_VIRTUAL_HOST", "%2f")
-    return f"{scheme}://{username}:{parse.quote(password)}@{hostname}:{port}/{virtual_host}"