|Name||Description||Introduced in Version|
|OAuth/OIDC Support in Python API|
OAuth / OpenID Connect has been added as a method of authenticating and authorizing clients connecting to the PubSub+ Event Broker using the SMF protocol. Clients using Solace APIs will be able to present a token as a credential during client login. This enables clients to integrate with modern identity and access management systems.
|Update Python API to Use Contemporary Python Version and Contemporary Python Tagging|
Changed tagging procedure to properly package for PyPi.
|Support for Kerberos Client Authentication|
Added Kerberos as a client authentication scheme.
|Additional Direct Receiver Back Pressure Strategies|
Added "drop latest" and "drop oldest" strategies to the Direct Receiver Backpressure buffer. This gives more options for what to do with messages received when the message buffer fills.
|Replay After Replication Group Message ID|
Applications can now replay messages following the message-ID of the last message which they successfully processed.
The feature uses "replication group message ID", which uniquely identifies messages within an HA group and Replication/DR group of brokers. The broker includes this ID in all guaranteed messages it delivers to the consumer. Consuming applications can extract and save this ID along with the message payload, and then use it later to initiate a replay.
This is a more "fine-grained" way to start a replay than from date-and-time, and is ideal in cases where the last message-ID successfully processed is known by the application (e.g. recovery from a database crash).
To initiate replay after message-ID from an application, both the PubSub+ Event Broker and PubSub+ Event API must be upgraded. The following versions introduce support for replay after message-ID:
* PubSub+ Event Broker version 9.9.0
* PubSub+ Messaging API for Java(JCSMP) version 10.11.0
* PubSub+ Messaging API for Java version 1.0.0
* PubSub+ Messaging API for C version 7.18.0
* PubSub+ Messaging API for JavaRTO version 7.18.0
* PubSub+ Messaging API for .NET version 10.12.0
* PubSub+ Messaging API for Python version 1.2.0
|Direct Messaging Request/Reply|
The API now supports synchronous request/reply with helper classes to await response from a replier.
|Structured Data Type Support for Publish and Consume|
The API can now consume messages published with SDTMap and SDTStream and publish messages setting SDTMap and SDTStream.
|Message Replay Support|
The replay of messages from the replay log is now possible via the API. This is for temporal replay only. Replay from replication group ID will be included in a future release.
|Message Interoperability with other Solace Message Format (SMF) APIs Containing XMLContent|
Messages published with other Solace APIs populating XMLContent are now consumable by this API.
|Python API MVP (GA) Direct & Guaranteed Messaging|
This is the initial release of the PubSub+ Messaging API for Python. Solace created this API to support the rich Python ecosystem and help developers create applications in Python that take advantage of the broad features of PubSub+.
This version contains a feature set that allows for the common messaging patterns like publish/subscribe using Direct Messaging and Guaranteed Messaging. This API provides support for all deployments of PubSub+ across software, appliance, and cloud.
Future versions of the Python API will introduce more features as Solace builds out the roadmap for this API.
The Python API 1.0.0 supports:
* Connection management to PubSub+ event brokers
* Addition and removal of topic subscriptions
* Sending and receiving Direct and Guaranteed Messages
* Message compression
* Use of Selectors
The Python API 1.0.0 does not support the following features:
* Request/Reply message exchange pattern
* Message Replay
* Structured data types that allow interoperability between various architectures and programming languages
* PubSub+ Cache Client API support
* Session Transactions
* XA Transactions
* Queue browsing
* Kerberos authentication
|Reference Number||Description||Resolved in Version|
The Class of Service feature is not supported in the Solace PubSub+ Messaging API for Python.
The Python API fails to automatically re-bind to endpoints after reconnecting.
|Reference Number||Description||Introduced in Version|
Setting basic-username (via solace.messaging.authentication.scheme.basic.username) will no longer set the client username used for client-certificate authentication. Applications are now required to set client-certificate-username using solace.messaging.authentication.client-cert.username.
A large number of overlapping subscriptions in a single messaging service with a high rate of incoming matching messages from the broker may result in degraded performance.
Attempting to canonicalize very large messages on non-linux platforms (1MB+) via print or other means that invoke __str__() may not complete. When this occurs, the MessagingService will become unresponsive.
Messaging metrics within the Python API may be slightly out of sync (delayed) compared to the actual number of messages sent and received.
Attempting to disconnect the messaging service while it is in connecting state will cause the Python API to ungracefully shut down.
RequestReplyMessagePublisher.terminate() waits until all Future objects created by RequestReplyMessagePublisher.publish() are complete. All Future objects created and returned by RequestReplyMessagePublisher.publish() must be completed before terminate() can finish. Even if terminate has a shorter or zero time, it will block until the outstanding Futures are complete after the time has elapsed.
The application may choose to implement its own executor to call publish_await_response() for asynchronous publish. This will return a failure, as expected, on terminate.
After a service is disconnected, calling is_running(), is_terminating(), or is_terminated() may return the incorrect state for the Publisher or Receiver.