Diffusion 5.9 Release Notes

5.9.19 (15 Mar 2018)

Bugs cleared at release 5.9.19

.NET Unified API: ISessionOpenCallback methods could be called during reconnection attempts (18190)

ISessionOpenCallback and ISessionOpenContextCallback<TC> methods could be invoked during reconnection attempts. This would cause issues when paired with "connect-again" mechanisms that would use the same connection code path. This issue has now been resolved and ISessionOpenCallback, and ISessionOpenContextCallback<TC> methods are now guaranteed to be only thrown once during a sessions lifetime.

.NET Unified API: PushTechnology.ClientInterface.Data.JSON.IJSON.ToJSONString() returned invalid JSON (18413)

PushTechnology.ClientInterface.Data.JSON.IJSON.ToJSONString() could in some instances return invalid JSON. Most common errors were missing commas after empty array values and un-escaped control characters in field names or string values. This has now been fixed.

Replication: Closing replicated update source should release resources (18527)

Closing a replicated update source should free all resources associated with it across all servers in the cluster. It was observed that when the update source was in the standby state some resources would not be freed across the cluster. This could interfere with the registration of new update sources. This was because of the failure to broadcast the state change. This has been fixed so that state transitions are consistently broadcast to the cluster.

Server: Requests from different sessions were not load balanced across available handlers (18518)

Control sessions can register multiple handlers with the server, including message handlers, authentication handlers, and queue event handlers. Due to a bug in previous releases, if multiple handlers were available, requests from different sessions were all routed to the same handler. The bug has been fixed. If multiple handlers are available, requests from different sessions are now distributed across them. Repeated requests from the same session are routed to the same single handler in a "sticky" fashion.

5.9.18 (7 Feb 2018)

Changes made to existing features at release 5.9.18

Fan-out: Optimize the evaluation of MissingTopicNotification (18179)

When using fan-out distribution, the server skips evaluation of a missing topic notification if there are no missing topic notification handlers. This improves performance for some configurations.

Bugs cleared at release 5.9.18

JavaScript Unified API: TypedSubscription TypeScript definition declares methods that are not implemented (18311)

The TypeScript definition for TypedSubscription was not correct. It extended Subscription, including methods like asType that are not implemented for the ValueStream. The definition has been changed to extend Stream.

Replication: ConcurrentModificationException deregistering distributed resources (18302)

Access to the registry of certain distributed resources (such as update sources) was not thread-safe. This could cause access of stale data or throw a ConcurrentModificationException when interleaving access and modification. The registry has now been made thread-safe.

Replication: IllegalStateException error message does not match the cause of the problem (18306)

The IllegalStateException error message "Unable to register above or below existing sources" did not accurately describe the cause of the problem. The message has been corrected to give more contextual information.

Server: Compressed message sent with incorrect body (18354)

When using the Publisher API to send compressed messages, it was possible for a message to be sent with the body of another, unrelated message. The defect has been fixed in this release.

5.9.17 (22 Jan 2018)

Bugs cleared at release 5.9.17

Apple Classic API: NSAssert calls in the Release build (18108)

Certain sequences of calls to the library, before a connection to the Diffusion server had been established, were causing an assertion exception to be raised even when using the release build of the library. This has been fixed.

C Unified API: Message loss when C client internal queue limit is reached (18143)

A flow control mechanism has been introduced which applies back pressure to the C client's internal queue. This ensures that messages will not be lost as a consequence of a C client application reaching its internal queue limit.

Monitoring: Topic instance message statistics don't work (18110)

If topic instance statistics were enabled in the configuration, the outbound.bytes and outbound.messages metrics were always zero in the console. Further, the JMX statistics reporter mapped these metrics to incorrect MBean paths. Both problems have been fixed in this release.

5.9.16 (28 Nov 2017)

Bugs cleared at release 5.9.16

Replication: Starting a server cluster with updating topics fails to complete (18090)

When using topic replication, the process of starting a server cluster could fail to complete in rare cases when there were incoming topic updates. This has now been resolved.

5.9.15 (23 Nov 2017)

Bugs cleared at release 5.9.15

Adapters: NullPointerException thrown by JMS Adapter if <topics> not specified (17634)

JMS adapter now correctly throws an APIAdapterException instead of a NullPointerException when the topic being subscribed to has not been created by the JMSAdapter.

C Client: C examples fail to compile under Windows (17254)

Minor adjustments have been made to the C client examples to ensure they can be compiled and executed on Windows.

C Client: C client struggles to establish a session via wss:// (17913)

Addresses an issue where a secure (wss) connection to a Diffusion server is only intermittently established. This was due to a bug in the underlying websocket library internally packaged with the client. This issue has been resolved with an upgrade to the library.

C Unified API: Remove register_state_provider from the C API (17784)

The C client wrongly included the "topic provider" feature which is no longer supported by the Diffusion server. This has been corrected.

C Unified API: Slave topics not supported in C API (17967)

The C client API has now introduced support to add slave topics. Existing applications that wish to use this will need to recompile the source code with the new client library. This is due to a necessary change in the API's implementation.

Console: Console client throws an exception when subscribing to a binary topic (17824)

Addresses an issue where subscribing to binary topics in the Console 'Topics' tab threw an exception in the browser console log. This was due to a client side parsing error for binary data on the Console. This has now been resolved - the console will now display data from binary topics as hexadecimal.

Java and Android Unified API: Split-path and full-path selectors containing regex quoting can fail to match (17997)

A split-path pattern selector containing an escaped regex metacharacter could fail to match a corresponding topic path. For example, the regex ?a\\$ failed to match the topic path a$. This has now been resolved.

Replication: Update version of Hazelcast to 3.6.8 (17766)

The Hazelcast data grid, a third-party component of Diffusion, has been updated from 3.6.4 to 3.6.8. This brings in the latest Hazelcast fixes for the 3.6 codebase.

Replication: Improve Hazelcast exception handling (17767)

Hazelcast exception handling has been improved. Additional unchecked exceptions are now caught and handled. These include the HazelcastInstanceNotActiveException that may be thrown when Diffusion is shutting down and the MemberLeftException that may be thrown when attempting to communicate with a server that has just left the cluster.

5.9.14 (27 Sep 2017)

Bugs cleared at release 5.9.14

.NET Unified API: AddTopicFromValue throws exception on large Record content (17763)

A System.ArgumentOutOfRangeException exception could be thrown when creating a record topic containing a large amount of data using a .NET client. This is now fixed.

C Unified API: Session properties listener not working with the C API (17668)

The C client failed to correctly deserialize session property events. This has been corrected.

Licensing: Licence grace period inconsistency for mobile and fan-out clients (17675)

When a Diffusion licence expires, there is a grace period before the product stops working. The grace period was not being applied correctly for mobile and fan-out clients. This is now fixed.

5.9.13 (14 Sep 2017)

Bugs cleared at release 5.9.13

Server: Server rejects WebSocket connection attempts that fail to complete within the connection timeout (17531)

The server-side connection timeout was not correctly applied to WebSocket connection attempts. This has been fixed.

5.9.12 (24 Aug 2017)

Changes made to existing features at release 5.9.12

Fan-out: Log fan-out connection state changes (17392)

Changes to the session state for fan-out connections are now logged at INFO level as PUSH-000713 messages. This makes it easier to monitor and troubleshoot fan-out connections.

Bugs cleared at release 5.9.12

Android Client: Java jarsigner verification fails on Android client JARs (17383)

The Android client JARs for previous versions were modified after signing, causing jarsigner checks to fail with a java.lang.SecurityException SHA-256 digest error. This is now fixed.

C Client: C library uses gcc specific macro __attribute__ (17253)

In previous versions, the diffusion.h header file used a macro that only works with gcc, preventing compilation with Microsoft Visual Studio. This has now been resolved.

C Unified API: Client unable to process messages when the internal queue is full (17191)

Dispatching a large number of messages to the server (over the Websocket transport) caused the client to lose messages pending dispatch once an internal queue limit was reached. The client has been improved to avoid this happening.

Fan-out: Fan-out replicates Diffusion topics if "*.*//" (all topics) selector used (17375)

If a fan-out link was configured to select all topics using the "*.*//" selector, it would replicate topics in the Diffusion branch which contain information about the Diffusion server. These topics should not be replicated because doing so can cause access failures. Now if a fan-out link is configured to select all topics, the selector will be replaced so that it selects all topics except those in the Diffusion branch.

Flash Classic API: Diffusion flash swf file not deployed to /html/lib/DIFFUSION (17345)

Addresses an issue where the classic Javascript client was unable to establish a connection using the Flash transport. This was due to a missing file dependency.

Java and Android Unified API: IllegalStateException on subscription notification after fail over (17459)

Diffusion clients sometimes threw an IllegalStateException when subscription notifications were received after failover. This prevented subscription notifications being passed to any streams which had registered them. The problem was caused by a race between the cleanup of state from the previous connection and the new state received after failover. This has now been fixed by ensuring the state of the previous connection is cleaned up before any new state can be received.

JavaScript Unified API: SessionEventType constants undefined in the JS library (17346)

The JavaScript client documents the SessionEventType enum as part of the ClientControl feature (see: https://docs.pushtechnology.com/docs/5.9.12/js/Session.clients.html#.SessionEventType), but this enum was not exposed through the public namespace. This has now been resolved.

JavaScript Unified API: JavaScript client reconnection timeout and recovery buffer size not set correctly (17470)

The reconnection timeout and recovery buffer size values were not being set correctly for JavaScript clients, causing a value of 0 to be used. This could result in unnecessary memory usage and more frequent reconnection attempts than expected. This has now been resolved.

Logging: PUSH-000591 log message wrongly displayed when using a rotation setting for logs (17396)

A PUSH-000591 message was wrongly displayed when using a log rotation setting with the <file-append> element in Logs.xml set to false or not present. The message falsely said that <file-append> was enabled and logs would not be rotated, even though logs were being rotated as expected with this configuration. This issue is now fixed and the message is not displayed.

Server: Server does not report client disconnection due to MESSAGE_QUEUE_LIMIT_REACHED (17293)

Clients disconnected due to MESSAGE_QUEUE_LIMIT_REACHED were not correctly notified of the disconnection by the server. This is now fixed.

Server: NullPointerException after logging large messages (17379)

A NullPointerException could happen after logging a very large message. The incorrect management of a thread local buffer was causing subsequent messages to generate the NullPointerException. This is now fixed.

5.9.11 (5 Jul 2017)

Changes made to existing features at release 5.9.11

Android Unified API: Android client libraries added to Maven public repository (17092)

The Android client is now available from the public Push Technology Maven repository.

Bugs cleared at release 5.9.11

.NET Unified API: Incorrect parsing of JSON strings that contain null values. (17168)

Reading a JSON string into a JSONDataType would create faulty binary data to be sent over the network, if the given JSON value contained fields with null values. For example, a JSON string of "{ "key" : null }" would create the equivalent binary data of a JSON string like "{ "key" : }". This has now been fixed, and null values are correctly parsed into the JSONDataType.

Fan-out: Fan-out does not retry in the event of DNS problems (17026)

Fan-out would not try to reconnect in the event of a failure due to an unknown host exception. This has now been resolved.

Java & Android Client: Failure to allocate very large buffers (17145)

A buffer management bug has been fixed. Previously, if a client session sent a very large request (larger than 1 GiB) to the server, the server could fail to allocate a suitable buffer. Even with the fix, the server can only allocate such a buffer if memory is available. To protect against malicious or poorly behaved client applications, we recommend configuring the server to restrict the maximum message size.

5.9.10 (18 Jun 2017)

Changes made to existing features at release 5.9.10

.NET Unified API: Default NLog.config file is now shipped with the client library (16898)

A default NLog.config file is now shipped with the .NET client library. This config contains two enabled targets (debugger & console) which output logging information at INFO level on the standard console. There is also a target to write the log to a file which is commented out. If you want to use it, simply uncomment it. For more information on NLog output please visit the official NLog documentation page: https://github.com/NLog/NLog/wiki/Configuration-file

.NET Unified API: Maximum message size can now be set independently from the input and output buffer size (16998)

Previously, the maximum message size could be no larger than the input and output buffer size. Now the maximum message size can be set to any size, independently from the input and output buffer size. This is useful when you don't know the maximum message size and want to set it to a high value while keeping the input and output buffers small.

Bugs cleared at release 5.9.10

.NET Unified API: ITopicDetailsBuilderFactory.CreateDetailsBuilder<IUniversalTopicDetailsBuilder>() throws KeyNotFoundException (16893)

ITopicDetailsBuilderFactory.CreateDetailsBuilder<IUniversalTopicDetailsBuilder>() would throw a KeyNotFoundException instead of returning a valid IUniversalTopicDetailsBuilder instance. This behaviour has now been fixed and ITopicDetailsBuilderFactory.CreateDetailsBuilder<IUniversalTopicDetailsBuilder>() will now return a valid IUniversalTopicDetailsBuilder instance.

Apple Unified API: Attributes of some topic types incorrectly serialised when adding topics (17018)

Fixes an issue with "add topic" requests sent by the Apple client library to the server. Both properties and initial values (where allowed) were being corrupted for the following topic types: Custom, Paged String, Routing, Slave, Stateless, Topic Notify and Protocol Buffer.

C Unified API: session_id_create_from_string() incorrect on Windows (16881)

Some sessionID strings would fail to parse on Windows. This was caused by a numeric underflow in the C Unified Client when parsing a string representation of a session ID to a SESSION_ID_T structure. This has now been resolved.

Console: Security tab does not show role assigned to anonymous sessions in Security.store (16908)

The security tab of the console now shows roles assigned to anonymous and named sessions in Security.store.

Java and Android Unified API: DataType write operations should not close the output stream (16888)

Writing a value to an output stream (using DataType.writeValue(...) or DeltaType.writeDelta(...)) would close the output stream after the operation completed. This has now been corrected so the output stream is not closed after the operation.

Java and Android Unified API: If the maximum message size is exceeded, the client session enters reconnect state (16951)

Fix an issue when a Java client receives a message exceeding the maximum message size from the server, the client will now close its connection with the reason MESSAGE_TOO_LARGE. In previous versions, the client went into the reconnect state and sent a reconnect request to the server.

JavaScript Unified API: diffusion.selectors.parse only parsing the first argument given (16976)

diffusion.selectors.parse was only parsing the first argument supplied. It now parses multiple arguments.

Server: Server log should record clearer information about missed pings (16889)

When a client is disconnected due to a CLIENT_UNRESPONSIVE state, the information logged by the server is now improved to make it easier to understand.

Server: Close session when client sends a message that exceeds the maximum size (16923)

Fix an issue when a client session sends a message exceeding the maximum message size configured on the server. In previous versions, the server disconnected the client instead of closing down the client session. This caused the client to try reconnecting to the server. The server now closes the session with the reason MESSAGE_TOO_LARGE.

Server: Fix reconnection failure if client attempts to reconnect more than once (17012)

If a Diffusion client attempted to reconnect after a prior successful reconnection, the connection would be closed by the server. This was due to an incorrect state transition. This has now been addressed and there is no longer a limit to the number of times a client may reconnect to a given server.

5.9.9 (16 May 2017)

Changes made to existing features at release 5.9.9

.NET Unified API: General performance improvements (15450)

Improved performance of logging and overall message throughput. However keep in mind that logging at DEBUG level is still quite costly under heavy load and will slow down your client significantly. Logging at this level should only be used to identify issues during development. Use INFO level for production environments.

Server: Improved unsubscription performance (16877)

Compared to previous releases, the CPU cost of unsubscription has been reduced, particularly for sessions that have subscribed to many topic selectors.

Server: Reduced CPU cost of topic removal when there is a large number of topics (16921)

An optimization has been added to topic removal, reducing the processing cost. This optimization is particularly beneficial if the server is hosting many topics.

Server: Optimize internal timer processing (16924)

A performance improvement has been made to internal scheduling code to reduce its CPU cost.

Bugs cleared at release 5.9.9

.NET Unified API: Socket timed out after 2 seconds of unsuccessful writing (16818)

When sending a message with the .NET client over a congested network, socket writes can sometimes take more than 2 seconds causing the socket to throw a timeout-exception which would terminate the client application. The timeout for socket writes has been disabled, leaving flow control in the hands of the higher level async IO engine.

C Unified API: Client's view of the topic details cache is not corrected following failover (16489)

With session replication enabled, a session using TopicControl that failed over to a new server could fail to add new topics. This has now been resolved. If a topic add fails because of cache issues, the session will clear the cache and retry adding the topic.

JavaScript Client: Wrong dependency set in js-uci-client when uploaded to npm (16789)

Some versioning issues with the version of the Diffusion JavaScript client uploaded to npm have been resolved.

JavaScript Unified API: CloseReason lacks a specific ACCESS_DENIED constant (16797)

The JavaScript client provides the CloseReason enum to represent why the client was closed, or the initial connection attempt was rejected - however, the CloseReason enum lacked a specific constant to represent authentication errors. ACCESS_DENIED has now been added, allowing users to determine if a connection attempt was rejected due to authentication issues.

Replication: Failure to resolve inconsistencies between two servers being merged into a cluster (10788)

When servers are merged into a Hazelcast cluster there may be inconsistencies between servers that cannot be resolved. An example inconsistency is multiple update sources for the same path being marked as active. This may happen when a network partitions and then heals. When it is not possible to resolve the conflicting data the servers being merged in will be shutdown. New servers can then be started that will recover consistent data from the cluster.

Topics: Issues with removal of a non-leaf topic (16787)

There was an issue where when a topic was removed from a non-leaf node then in some cases the topic's statistics were not updated and in the case of a slave topic it might not be detached from its master properly. This problem has now been resolved.

Unified API: Duplicate DISCONNECTED events received by SessionPropertiesListener (16800)

The SessionPropertiesListener could receive duplicate session DISCONNECTED event notifications. This could happen if the disconnection was detected in two different ways. The second disconnection is now being filtered. Only a single DISCONNECTED event will be dispatched to the listener.

5.9.8 (18 Apr 2017)

Features introduced at release 5.9.8

.NET Unified API: Added ISessionFactory.MaximumQueueSize() (16762)

The new function ISessionFactory.MaximumQueueSize() has been added to allow .NET clients to set their outbound queue size. This is useful for .NET control clients that may be publishing large amounts of bursty data.

Changes made to existing features at release 5.9.8

Logging: Enhance reporting of close reasons (16673)

When a client session is closed due to a network error the closure is now logged at INFO level rather than DEBUG. Although network errors are often benign, it is safer to be sure and log the closure regardless.

Server: Reduced CPU cost when removing sessions (16699)

An optimization has been added to batch session removal post-processing, reducing the processing cost. This optimization is particularly beneficial if the server is hosting many topics.

Server: Ensure a processing backlog doesn't starve network write operations (16736)

Output processing has been refined to ensure network writes continues when there is a large backlog of other processing. Messages will be delivered in a more timely delivery manner. This may reduce disconnections due to ping timeouts when the server is heavily loaded.

Bugs cleared at release 5.9.8

.NET Unified API: Value cached on first update regardless of result of update request (16415)

The value cached for a topic was always stored when an update for the same topic would be performed, regardless of whether the request to update succeeded or failed. This issue has now been resolved. In case of an error or failure, the cache entry is now removed.

.NET Unified API: JSON serialization invalid when current culture set to a non-English variant (16715)

When setting the CultureInfo.CurrentCulture to a culture that does not use a period (.) as its floating point separator, the JSON serialization and deserialization produced invalid results, even if the provided JSON string was perfectly valid. For example calling Diffusion.DataTypes.JSON.FromJSONString() with a JSON string containing a floating point value would throw an InvalidDataException(). Calling IJSON.ToJSONString(), for example, would create invalid JSON if it contained a floating point value. To fix this error JSON serialization and deserialization is now using CultureInfo.InvariantCulture internally and ignores CultureInfo.CurrentCulture entirely. This change will only have an effect on your program behavior if you were using a specific CultureInfo that is different to English and you were relying on the output of IJSON.ToJSONString(). All other use cases remain the same. Ensure that you use a period (.) as your floating point separator when parsing a JSON string into a JSON datatype.

.NET Unified API: Queuing a message on a full message queue is a blocking operation (16771)

When the .NET client is unable to send messages quickly enough due to network congestion its outbound queue fills up. When trying to queue further messages the operation blocks and prevents other network operations resulting in CONNECTION_RESET being reported and the connection being closed. This fix ensures that attempts to enqueue new work do not prevent existing work from being processed. To cope with large bursts of traffic customers are advised to increase the outbound client queue size.

Apple Unified API: Completion handlers and delegates not informed of failure on reconnect with message loss (16695)

A session that reconnects to another server will fail to inform completion handlers and delegates of failure when there has been message loss. This bug has been fixed.

Classic API: Initial messages lost when using forever frame transport (16676)

The forever frame transport is an HTTP based transport that streams messages as a chunked response to a poll request. The forever frame transport was incorrectly treated as immediately available for sending messages to the session by the server. This meant that messages were sent to the session before the poll request was sent. These messages were not correctly processed. This would usually happen when an initial topic selector was used. The server now waits until it has received a poll request before sending any messages.

Java and Android Unified API: Simultaneous topic updates throw a ConcurrentModificationException when updating the topic update cache (16690)

Addresses an issue where multiple concurrent updates to the same topic could cause a ConcurrentModificationException to be thrown on the client.

JavaScript Unified API: Use latest version of Hashmap dependency to support ECMA 5 non-conformant browsers (16751)

The Hashmap dependency has been updated in order to support browsers that do not conform to the ECMA 5 specification when calling toString on a null object. This resulted in users of Microsoft Edge and versions of iOS <9 experiencing an error, particularly when a polyfiller is used to modify the default behavior of the browser.

JavaScript Unified API: Not parsing semantic block in CBOR - "Unkown CBOR header type: 6" (16758)

The JavaScript client would throw an error when parsing a JSON topic containing a semantic CBOR tag. Embedding semantic data inside JSON topics is currently unsupported and semantic CBOR tags are now ignored.

Misc: Github Java examples do not build (16700)

The Diffusion Java examples on GitHub did not build due to a missing dependency. This problem has now been resolved.

Publisher API: Restore performance of Publisher.getNumberOfTopics() (16735)

In Diffusion 5.9.0, Publisher.getNumberOfTopics() became expensive to evaluate, particularly if there are a large number of topics. The implementation has been changed to restore the performance.

Replication: Session replication recreates topic selections inefficiently, leading to large memory footprint after recovery (16561)

The recovered topic selections were not interned in memory following recovery after failing over. This would cause sessions that failed over from another server to have an increased memory footprint. The topic selections are now interned, reducing the memory used.

Unified API: Fail-over topic cache maintenance is incorrect (15704)

When using topic replication, a session that reconnects to another server could fail to receive unsubscription notifications for topics not present on the new server. This bug has been fixed. The session will now receive an unsubscription notification with the reason SUBSCRIPTION_REFRESH for each previously subscribed topic, followed by subscription notifications as the new server re-evaluates the session's topic selectors.

5.9.7 (20 Mar 2017)

Changes made to existing features at release 5.9.7

Server: Improved subscription evaluation to reduce cost of adding topics (15779)

Each new topic is matched with each session's topic selectors to determine whether the session should be subscribed to the topic. When there are many sessions, the matching process can be computationally expensive and restrict the rate at which new topics can be added. A new index structure has been added which, together with other optimizations, significantly reduces the cost of topic addition for most applications.

Server: Remove conversation tracking for subscription and unsubscription notifications to reduce memory costs (16630)

Improvements have been made to reduce the memory costs associated with subscription and unsubscription notifications.

Bugs cleared at release 5.9.7

.NET Unified API: Client's view of the topic details cache is not corrected following failover (16487)

With session replication enabled, a session using TopicControl that failed over to a new server could fail to add new topics.

Apple Unified API: Client's view of the topic details cache is not corrected following failover (16488)

With session replication enabled and on failing over to a new server, a session using the PTDiffusionTopicControlFeature could fail to add new topics.

Documentation: Connector timeout default documented incorrectly (16540)

The Connectors.xsd and User Manual incorrectly stated that if no value is specified in the Connectors.xml file for connection-timeout, it defaulted to 2s. However, the correct behavior is that the connection-timeout value defined in Server.xml is used instead. This is now documented correctly.

Java and Android Unified API: Client's view of the topic details cache is not corrected following failover (16486)

With session replication enabled, a session using TopicControl that failed over to a new server could fail to add new topics. This has now been resolved. If a topic add fails because of cache issues, the session will clear the cache and retry the topics add.

Server: Routing topic handlers are no longer called for already subscribed topics (16568)

In previous releases, when a session subscribed, routing topic handlers would be called for routing topics that match the topic selector regardless of whether the session was already subscribed. If the session was already subscribed to a topic, the routing topic handler response would be ignored. In this release, the routing topic handler will not longer be sent these redundant routing requests.

Server: Downgrade PUSH-000576 warn in logs (16609)

When Diffusion is configured to use log4j2 logging, a message is logged on start up reporting that the log configuration is ignored. In this release, the message severity has been downgraded from WARN to INFO.

Server: Negative value logged for suppressed messages in server logs (16610)

Suppressed logs could sometimes display a negative number of suppressed messages. This has now been fixed.

Server: Suppress PUSH-000191 log messages (16612)

When PUSH-000191 log messages occur in quick succession they will now be suppressed.

5.9.6 (14 Mar 2018)

Bugs cleared at release 5.9.6

.NET Unified API: max-message-size not enforced on inbound messages over DPT & HTTP (16506)

The max-message-size was not enforced on inbound messages while connected over DPT or HTTP. However, it would result in a DiffusionAPIException when connected over WebSocket. The behavior for DPT and HTTP have now been changed to be the same as the WebSocket behavior: Receiving messages larger than the defined max-message-size will now correctly result in a DiffusionAPIException on every protocol.

Java and Android Unified API: Value cached on first update regardless of result of update request (16416)

Addresses an issue where failed topic update can be stored in a session's topic update cache

JavaScript Unified API: JavaScript client disconnects immediately when system ping is disabled (16537)

The JavaScript client did not correctly handle a connector that had the system ping disabled. This resulted in the client disconnecting. The JavaScript client now detects the connector configuration correctly and remains connected.

Server: NullPointerException when processing a request for a disconnected client (16535)

A NullPointerException is no longer thrown.

Server: Empty elements not detected in topic path when adding topics (16562)

Empty elements were not being detected in topic paths when creating topics, leading to a path of a//b causing a topic a/b to be created. This has now been resolved and paths with empty elements will be treated as invalid.

5.9.5 (22 Feb 2017)

Features introduced at release 5.9.5

Replication: Replication support for slave topics (16368)

Replication support for slave topics. Slave topics are now replicated between Diffusion servers in a cluster when topic replication is enabled. If some of the Diffusion servers in your cluster are version 5.9.4 and earlier and others are 5.9.5 and later, this change can cause inconsistent behaviors when replicating branches of the topic tree that contain slave topics. To ensure consistent behavior when replicating slave topics, update all of your Diffusion servers to 5.9.5 and later.

Bugs cleared at release 5.9.5

.NET Unified API: Reconnection stability (16400)

Reduced the number of cases in which reconnection would fail due to message loss. It is also now guaranteed that the last reconnection attempt runs to completion even if the reconnection timeout has been reached.

.NET Unified API: TCP keep-alive frequency set to a high value (16477)

The TCP keep-alive frequency was set to a very high value for .NET client connections and it would generate a lot of noise on the wire. TCP keep-alive is now disabled by default for .NET client connections in favor of our own keep-alive mechanism (See pings).

.NET Unified API: Delays when sending large content to the remote host (16482)

Sending large content with the .NET client library caused delays of several seconds or in the worst case even minutes. These delays would cause ping responses to the server to arrive after the ping timeout which would result in the server closing the client connection due to unresponsiveness. Performance for large content has now been increased to minimize the delay.

Android Classic API: Android client does not parse the final field of a message if it is empty (16387)

Classic Android clients will now correctly parse records that have an empty field on the end.

Documentation: Java examples on GitHub depend on org.json which is not specified in pom.xml (16407)

The pom.xml has been updated to include the org.json dependency.

Server: NullPointerException when receiving corrupt credentials message (16428)

If a classic credentials message was tampered with mid transit, when the message reached the server it could lead to a NullPointerException in the Inbound Thread. This has been addressed.

Unified API: Session properties events can be received before the registration callback (16511)

Session properties events may be received by listeners before the registration callback. This happened due to the race between activating the listener and sending the initial events to it. The race has been fixed and the registration callback should be notified first.

5.9.4 (6 Feb 2017)

Bugs cleared at release 5.9.4

.NET Unified API: Incorrect JSON parsing (16362)

Fixed an issue when a numeric string is used as a key in a JSON string.

Apple Unified API: Use DISPATCH_CURRENT_QUEUE_LABEL instead of dispatch_get_current_queue() for logging (16356)

Fixes the potential for a crash when runtime logging had been enabled and the name of the current dispatch queue formed part of the logged output. Runtime logging should not be enabled for production app builds, so this bug will have only been encountered during development.

C Unified API: No topic selector type should be treated the same as "Path" (>) (16289)

When using topic selectors, a missing selector type is now correctly treated as a full path selector (">").

Console: Console memory parser does not support scientific notation (16230)

Charts on the console now continue to work with large numbers represented by scientific notation.

Documentation: JavaScript API Docs refer to session.topics.TopicType which doesn't exist (16239)

The JavaScript documentation has been improved to link correctly to session.topics.TopicType

Documentation: Correct interoperability statements in the manual (16323)

The Interoperability page in the manual stated that 5.1 Unified clients are supported against 5.7 and later servers. This is not the case.

Fan-out: Fan-out issues on reconnection (16304)

There were some issues with fan-out reconnections, especially when a link included a very large number of topics. A disconnection whilst the link was being established could result in the link being in the wrong state after reconnection which could result in non replication of topics. These problems have now been resolved.

Fan-out: Fanout schedule connect attempt logging should be in milliseconds (16307)

PUSH-000538 log message indicated that a fan-out connection would retry in a number of seconds when it should have read milliseconds - this has now been corrected.

Java and Android Unified API: Session ErrorHandler onError called spuriously after client close (15916)

Addresses an issue where a session's error handler may be called before the session closes, due to an incoming delta message from a subscription.

Java and Android Unified API: Possible NullPointerException on session connection (16210)

There is a race condition during session connection. If a session receives a message after the connection handshake but before the session has been initialized, a NullPointerException may be generated. This has been fixed by keeping any inbound messages queued until after the session has been initialized.

Monitoring: Race condition between starting and stopping topic instance statistics (16209)

A race condition was found when removing and adding back a topic with the same path when topic instance statistics were enabled. The topic instance metrics were added before being removed. The race condition has been fixed.

Server: Update sources might stop changing state if notifying a session of state change fails (16079)

If notifying a session of a state change failed, an update source could have failed to respond to the registration and unregistration of other update sources. Defensive code has been added to ensure that the update sources remain in a consistent state if notifying a session or the cluster of a state change results in an exception being thrown.

Server: JSON and Binary topics publish a delta when it would be cheaper to publish the new value (16252)

JSON and Binary topics now reliably publish a new value rather than a delta update if the serialized form of the new value is smaller than the delta.

5.9.3 (11 Jan 2017)

Changes made to existing features at release 5.9.3

Java and Android Unified API: RoutingSubscriptionRequest API documentation has been corrected (16036)

The RoutingSubscriptionRequest API documentation has been corrected: If (defer/subscribe) is called twice, IllegalStateException is not thrown. The operation is sent to the server, which will log a warning as the conversation no longer exists and fail the call with a COMMUNICATION_FAILURE reason. The client callback will be discarded.

Product Release: Distribute unminified JavaScript client source (16057)

The unminified JavaScript source is now distributed along with the minified source.

Server: MetadataCodec - pool JAXB objects in a thread local. (16027)

The performance of XML parsing of record topic data metadata has been improved.

Bugs cleared at release 5.9.3

.NET Unified API: OnClose being called for registered handlers and listeners upon entering Reconnection (16121)

From v5.8, the expected behavior is that conversations are kept upon entering reconnection and only discarded upon session close. This issue resulted in the server and the client having a contradictory view of the states of the session and its listener and handlers. This issue has now been resolved.

Android Unified API: Notify the server when handlers are removed because they threw an exception (16183)

Handlers registered with the server are closed if their callback methods throw an exception. When this happens they will not continue to receive notifications from the server. However previously the server would continue to attempt to send notifications to the handler. The server is now informed of the handler close and stops sending notifications to it.

Cloud: Console disconnection when under load (16179)

A memory leak has been fixed which caused console clients to disconnect when many clients connect to the server.

Documentation: Diffusion send message example is not complete (Java) (16101)

Updated the ControlClientReceivingMessages.java example to demonstrate sending a message as Content and JSON. Also now shows how a JSON message can be decoded.

Fan-out: Fan-out client does not restart if the fan-out subscription is discarded (16054)

Fanout client will now start a new connection if the fanout link subscription is discarded.

Java and Android Unified API: Notify the server when handlers are removed because they threw an exception (15032)

Handlers registered with the server are closed if their callback methods throw an exception. When this happens they will not continue to receive notifications from the server. However ,previously the server would continue to attempt to send notifications to the handler. The server is now informed of the handler close and stops sending notifications to it.

Java and Android Unified API: A routing subscription handler can subscribe a session to source and routing topics to which it has no access (16037)

Access control checks were not properly applied. This allowed a routing subscription handler to complete a routing subscription even if it did lacked READ_TOPIC permission for both the a session to source and routing topics . This has been corrected.

Java and Android Unified API: Polling client send request should be processed only when ready (16050)

Fix an issue where polling client was processing pending messages when not ready.

Java and Android Unified API: CompositeControlAuthenticationHandler may not notify all delegate handlers (16085)

Exceptions thrown from the delegate methods of the CompositeControlAuthenticationHandler can interfere with calls to other delegates. The exception handling has been improved to ensure that the delegates receive appropriate invocations. An exception thrown by onOpen of a delegate will further delegates from being notified of onOpen and all delegates will be notified of onClose. An exception thrown by authenticate will cause the authentication attempt to be denied. The first exception thrown by onClose of a delegate will be propagated after all remaining delegates have been notified of onClose.

JavaScript Unified API: Upgrade Hashmap dependency in JavaScript Client (16052)

The Hashmap dependency has been upgraded to fix an issue when uglifying source code.

JavaScript Unified API: Missing documentation for custom credentials (16062)

The JavaScript Unified Client did not document that custom credentials could be provided by connection options. This has now been fixed.

JavaScript Unified API: Update values which do not correspond to any metadata or datatype do not cause an INCOMPATIBLE_UPDATE error. (16099)

When updating a topic with a value that does not have a corresponding Metadata or Data Type (i.e an Array), no error is emitted. This has now been resolved, and an UpdateFailReason.INCOMPATIBLE_UPDATE error will now be provided to the failure callback for the update result.

JavaScript Unified API: Calling session.close when disconnected and attempting reconnection (16110)

Fixed an issue where the connection would not enter the closed state when closing a session while reconnecting.

JavaScript Unified API: TypeScript definition improvements (16132)

Improvements have been made to the TypeScript definition.

Replication: Session keep-alive time too short for failover in the event of server failure (15775)

In a replicated cluster sessions are removed from the cluster if they do not fail over following the failure of the server they were connected to. Under high load there may not be enough time for all sessions to recover before they are removed. The keep-alive time has been increased by basing it on the greatest keep-alive time defined in the Connectors.xml configuration file.

Replication: UpdateSource transition may not occur when certain exceptions are thrown (16168)

Addresses an issue where an UpdateSource may not transition from STANDBY to ACTIVE (after a previously active UpdateSource has been closed) due to a non-fatal exception being thrown. This has now been resolved.

Server: Routing subscription request caused multiplexer error (IndexOutOfBoundsException) if routed session no longer existed (16012)

If a routing subscription handler responded to a request for a session, and the session had been closed in the meantime, the operation would fail. Further, this stopped a multiplexer threads. Full service could only be restored by restarting the server. This problem has been resolved.

Server: The server polling message channel should remain busy until receive the first poll request (16049)

The polling message channel will now be set to busy until the first poll request is received.

Server: Add Access-Control-Expose-Headers:diffusion-connection to HTTP response (16068)

Added "Access-Control-Expose-Headers:diffusion-connection" header to HTTP response for poll and send.

Server: Multiple license breach errors (16107)

License breach errors are now suppressed and reported in batches.

Server: Server memory leak when a Java session disconnects (16208)

Closing a Java client session could cause a memory leak on the server. The problem has been fixed in this release.

Server: Unnecessary retention of memory by cancelled scheduled operations (16219)

Scheduled time-outs unnecessarily retained memory when cancelled. This affected both the server and the Java client. For example, a closed session would stay in memory on the server until the reconnection time-out matured. From this release, memory is released for garbage collection when operations are cancelled, reducing the overall memory footprint.

Unified API: SessionPropertiesListener does not work over DPT (16113)

An unnecessary protocol restriction prevented the use of SessionPropertiesListener from a session connected using the DPT protocol. This restriction has been removed. Related restrictions have been lifted allowing the following: - TopicControl.remove() over DPT - Missing topic notification propagation over DPT fanout links

5.9.2 (2 Dec 2016)

Changes made to existing features at release 5.9.2

.NET Unified API: Session details are deprecated. (15607)

Session details are now deprecated. Use Session properties instead.

Console: CSS improvements in the console (15709)

The visual appearance of the console has been improved.

Unified API: Improved delta support for large JSON and Binary values (15537)

The delta calculation performed by the server has been refined to produce smaller deltas when the input values are large.

Unified API: Reduced delta message size for inputs that have many small differences (15545)

The binary difference engine has been optimized to reduce delta sizes for input values that have many small differences.

Bugs cleared at release 5.9.2

.NET Unified API: GC.Collect() called upon connection and disconnection (15664)

For every connection and disconnection attempt, the API would trigger the Garbage Collector. This issue has now been rectified.

Adapters: pushnotifications/pn_bridge.bat (15542)

Bugs have been eliminated from the Windows BAT file pushnotifications/pn_bridge.bat

Adapters: PushNotifications : "Unknown template variable 'topic.content'" (15793)

Correcting incorrect template variable 'topic.content' in pushnotifications/PushNotifications.xml

Adapters: Push Notifications: nothing prevents creation of templates with the same name (15830)

Uniqueness of <template> elements is now enforced.

Apple Unified API: Completion handlers and delegates can receive multiple calls on closure (15905)

Fixes an issue where completion handlers and delegates could be incorrectly informed of failure due to the session being closed. This could happen if the session was closed while handling a response from the server.

Configuration: Using an absolute path in the <default-log-directory> of the Logs.xml fails (15697)

Using an absolute path in the <default-log-directory> of the Logs.xml would not have the expected behavior, as it would try to append the absolute path to the path used for the Diffusion installation. This issue has now been rectified.

Console: Console panels act oddly with long (but not too long) titles (15171)

Panels in the console previously exhibited odd behavior when resizing the browser window. This has been resolved.

Console: Console topic tree refresh not always working (15590)

The topic tree tab of the console now refreshes after the console client disconnects and reconnects.

Console: Upon enabling client statistics and enabling monitor-instances, inbound and outbound messages do not update on the clients tab (15852)

Inbound and outbound message statistics now correctly update on the clients tab of the console.

Documentation: TopicPermission.READ_TOPIC documentation incorrect (15737)

The API documentation for the READ_TOPIC permission has been corrected. Previously it erroneously stated that it also restricted receipt of messages sent using the Messaging feature. The transmission of messages is only controlled through the SEND_TO_SESSION and SEND_TO_MESSAGE_HANDLER permissions.

Fan-out: Fan-out fails when custom max-message-size is configured in Server.xml (15778)

Fan-out failed to modify the max message size to coincide with the value set in the Server.xml. This issue has now been fixed.

Java and Android Unified API: Session wills must always be called in the context of a client (15907)

Under some circumstances session wills could be called with default user credentials. The client context is now appropriately enforced when a will is executed.

JavaScript Unified API: Promise values are undocumented (15682)

Promise Result values are now documented in the JavaScript API documentation.

JavaScript Unified API: Handler "onError" methods are called when a session is closed normally (15687)

The "onError" method for handlers registered in the JS Unified Client was incorrectly called when the registering session was closed. This has now been resolved, and the "onClose" handler method will be invoked instead.

JavaScript Unified API: session.unsubscribe does not return a promise (15689)

session.unsubscribe now correctly returns a promise.

JavaScript Unified API: Use of reserved keyword "implements" in JavaScript client (15727)

The JavaScript client was using a future reserved keyword "implements" that some JavaScript linters objected to. This has now been resolved.

JavaScript Unified API: JS constants 'TopicAddFailReason' and 'UpdateFailReason' are not exported (15748)

The Unified JavaScript client documented 'TopicAddFailReason' and 'UpdateFailReason' enums as error results for topic operations. However, these were not exposed through the Diffusion namespace as implied by the documentation. This has been resolved and the constants are accessible via 'diffusion.topics.TopicAddFailReason' and 'diffusion.topics.UpdateFailReason' respectively.

JavaScript Unified API: JS does not implement the unsubscription authorisation change (15780)

While the Unified JS client had implemented the 'AUTHORIZATION' UnsubscribeReason, the server's internal versioning model had not been updated to reflect this capability. This resulted in the server sending the 'CONTROL' UnsubscribeReason in situations where 'AUTHORIZATION' would have been expected. This has now been resolved.

Server: Newer HTTP client to older server handshake does not return downgrade response (15604)

Clients connecting over HTTP transports (WebSockets, Long Polling) that were of a higher protocol level than the server they were connecting to would receive an "OK" response instead of a "Downgrade" response. This would permit the client to operate as if it had successfully connected, despite the possibility of compatibility issues. This has now been resolved.

Server: Change the poll hander logging level when a client session is closed (15676)

Diffusion will no longer log a warning when a polling client closes a session. In addition setting the logging level to Error will no longer cause an invalid response from the polling handler.

Server: Missing context when sending a onSessionClose notification with the reason FAILED_OVER (15705)

Fixed an issue where an exception would be thrown when sending an onSessionClose notification with the FAILED_OVER reason to older clients.

Server: Possible NullPointerException in server when updating topics (15831)

There was the possibility that updates could fail in the server if a topic was removed at exactly the same time as an update was being applied - this has been resolved.

Server: Reconnection failures due to incorrect recovery buffer management (15835)

A bug in the management of the server-side recovery buffer could cause reconnection to fail unnecessarily. This problem has been rectified.

Server: Silent failure creating topics with leading slash (15871)

The server will now respond with failure when attempting to add a topic that begins with a leading slash.

5.9.1 (19 Oct 2016)

Features introduced at release 5.9.1

Adapters: JMS Adapter "Client Edition" (15219)

The JMS adapter can now run standalone, as a client of Diffusion or Reappt.

Changes made to existing features at release 5.9.1

Apple Unified API: New AUTHORIZATION unsubscribe reason (14839)

A new unsubscription reason (PTDiffusionTopicUnsubscriptionReason_Authorization) has been added which is used to report unsubscriptions due to a change in a session's assigned security roles.

Build: Package JMS control client in clients (15598)

The JMS control client adapter has been packaged so that it is available as a Reappt client in clients/jms. The client is also available on maven central.

Configuration: Deprecate assigned-roles element in Management.xml (15558)

The value for assigned-roles is only used by the users defined in Management.xml. Configuring users is deprecated so assigned-roles has been deprecated.

Eclipse Tools: Deprecate the Introspector/Eclipse plugin (15473)

This feature is marked deprecated, and will be removed in a future release.

Fan-out: Fan-out: propagate missing topic notifications (15360)

When using fan-out, missing topic notifications generated by subscription and fetch operations against a secondary server are now propagated to the relevant primary servers.

JavaScript Unified API: Accept port as a string (15476)

In the JS Unified Client, the "port" connection option now correctly handles and validates values provided as strings.

Bugs cleared at release 5.9.1

Apple Unified API: Messaging: correct handling of message that matches no streams (15387)

From this release, the implementation has been corrected to match the documented behavior. The client will always reject an inbound message that matches no streams. The server will log the rejection as a COMMUNICATION_FAILURE and report the delivery failure to the MessagingControl sender as a failure.

Apple Unified API: Linker cannot find PTDiffusionBytes (15448)

The symbols for the PTDiffusionBytes class were not available in the built library binary causing a linker error should an attempt be made to directly allocate an instance of this (base) class.

Configuration: Deprecation warning about acceptors in Connectors.xml when not present (15441)

Warnings about the use of the deprecated element acceptors in Connectors.xml are reported in the log when the element is not present. The warning was caused by the default value when the element was not set. This has been corrected so no warnings are reported when the element is present.

Console: DiffusionPublisher leaks closed introspector and console client sessions (15534)

The DiffusionPublisher was leaking memory. Each Introspector or console session would be kept in memory. These will now be released once the session closes.

Console: Console does not handle Access Denied exceptions gracefully (15569)

The console will now provide error messages instead of silently failing if the session credentials do not have sufficient permissions to perform console actions.

Java and Android Unified API: JSON.diff does not handle CBOR fixed length arrays and objects (15556)

When parsing a CBOR binary representation of JSON that contained a fixed length object or array, JSON.diff() could produce an invalid JSONDelta. This problem has been rectified.

JavaScript Unified API: Typescript definition does not support SessionEventTypes (15437)

SessionEventTypes have been added to the TypeScript definition.

JavaScript Unified API: TypeScript definition does not allow instantiation of String metadata (15438)

The Typescript definition now allows String metadata.

JavaScript Unified API: Stream#close not documented (15500)

In the JavaScript Unified Client, Stream#close - which is implemented by Subscription, TypedSubscription, and MessageStream - was not correctly documented. This has now been resolved.

JavaScript Unified API: sessionid.equals() does not tolerate other types (15592)

SessionId.equals() has been modified to allow comparisons with objects that are not SessionId

Server: MissingTopicNotification retries - cope with no further handlers (15489)

If a missing topic notification could not be delivered and is retried but there is no longer a registered missing topic handler, a NullPointerException was logged by the server. This has been corrected, and a warning message is now logged.

Server: Client-side timeout in AbstractOutboundHandshake interrupts thread (15595)

Addresses an issue where an InterruptedException is thrown on the server when an inbound client connection times out during connection.

Unified API: getSessionDetails returns 'unknown session' when there are no details (15471)

The 'get session details' capability of the client control feature in all unified clients would return an 'unknown session' callback if the session existed but had no details to return. This has now been fixed.

5.9.0 (29 Sep 2016)

Features introduced at release 5.9.0

Apple Classic API: Add Bitcode to classic library build (12411)

Explicit support for Bitcode has been added to the classic iOS client.

Apple Unified API: JSON and Binary topic type support (14058)

Adds the capability to generate and receive both JSON and Binary values. Support for adding value streams, either for PTDiffusionJSON or PTDiffusionBinary values, has been added to PTDiffusionTopicsFeature. PTDiffusionBytes is the new superclass above PTDiffusionJSON, PTDiffusionBinary and PTDiffusionContent. The PTDiffusionMessagingFeature now sends PTDiffusionBytes rather than PTDiffusionContent. Add topic methods on the PTDiffusionTopicControlFeature now accept initial values as PTDiffusionBytes rather than PTDiffusionContent. Instances of PTDiffusionTopicUpdater obtained from the PTDiffusionTopicUpdateControlFeature now accept PTDiffusionBytes rather than PTDiffusionContent.

Apple Unified API: Add convenience overload to Topics feature add topic stream to allow supply of string (14313)

New convenience method addTopicStreamWithSelectorExpression:delegate: added to Topics feature that takes NSString* and builds a PTDiffusionTopicSelector* from that.

Apple Unified API: New TopicControl.remove capability (15044)

New method removeDiscreteWithTopicSelectorExpression:completionHandler: has been added to PTDiffusionTopicControlFeature which will replace removeWithTopicSelectorExpression:completionHandler: (now deprecated). The difference being that it is now possible to remove a topic without removing its descendant topics in the topic tree hierarchy.

C Unified API: New topic_removal() service (15045)

Added a new service topic_removal() which supersedes remove_topics().

C Unified API: Allow maximum queue size to be configured for client API (15161)

A new function, session_set_maximum_outbound_queue_size(), has been added to manage the size of the queue used to buffer messages before transmission to the server.

Fan-out: Automated Fanout Reconnection (14899)

Automated fan-out now supports reconnection of fan-out connections to primary servers. Previously, if the connection between a secondary server and a primary server was lost the secondary server would remove all replicated topics and re-establish a new connection with the primary server. This is because previously fan-out could not make use of standard reconnection due to the possibility of message loss. Since release 5.8 reconnection without message loss is possible and therefore fan-out has now been changed to make use of this capability. This means that a fan-out secondary server that loses its connection to the primary server can now reconnect without any loss of topics. This is not enabled by default as the connector at the primary server also has to be configured to support reconnection. In order to enable reconnection from a secondary server the new reconnection timeout property must be specified in the fan-out connection configuration.

Fan-out: Fan-out support for Routing topics (15070)

Routing topics are now supported by automatic fan-out. When Routing topics are replicated then routing subscription handlers are only necessary at the secondary servers.

Java & Android Client: WebSocket support for compress encoding (13538)

The Java client now supports the transfer of compressed messages over WebSocket connections.

Java and Android Unified API: Java client support for HTTP Polling transport (13842)

Added polling transport to the Java Unified client. This allows the client to connect and interact with the server using the polling transport. The Unified Java client can now cascade among WebSocket and HTTP Polling transports when a list of transports is passed in as an option.

Java and Android Unified API: Java client connection cascading (14497)

Clients can perform connection cascading from a list of transports given to the session factory. For example: Diffusion.sessions().transports(WEBSOCKET, HTTP_POLLING). This will instruct the client to connect to the server using WebSockets. If it fails to connect using WebSockets, the client then tries again with HTTP polling. The client will cease cascading if the server returns a fatal error.

Java and Android Unified API: New TopicControl.remove capability (15041)

New 'remove' methods have been added to TopicControl which will replace the old TopicControl.removeTopics methods (now deprecated). The difference being that it is now possible to remove a topic without removing its descendant topics in the topic tree hierarchy.

Java and Android Unified API: Allow maximum queue size to be configured for client API (15153)

It is now possible to configure the maximum outbound queue size for a client connection via the SessionFactory.

JavaScript Unified API: SubscriptionControl feature (12789)

The JavaScript Unified Client now implements the SubscriptionControl feature, allowing control clients to subscribe or unsubscribe other sessions based on either SessionId or Session Filters. This functionality is accessed under the "session.clients" namespace.

JavaScript Unified API: Provide a TypeScript Definition file (13267)

A TypeScript definition is now available for download and is included in the Node.js client.

JavaScript Unified API: Add ability to specify the HTTP and WebSocket request path (15055)

The JavaScript Unified Client now provides a "path" connection option. This allows users to specify additional URL context for connections, beyond the existing hostname/port options.

Unified API: Automatic creation of intermediate topic nodes no longer creates stateless topics (14955)

Previously when a topic was created with a hierarchic name (for example, a/b/c) then if there was not already a topic at the ancestor nodes (for example, a or a/b) then stateless topics would automatically be created. This meant that where topics were required at several levels of the hierarchy they had to be created in top-down order. This is no longer the case and intermediate nodes that do not already exist will not have topics bound to them. This means that it is now possible to create topic a/b/c and then topic a/b after. This represents a change in behavior in that the intermediate stateless topics are not now created and applications that expected to be able to use them, or expected to become subscribed to them may need to be changed.

Changes made to existing features at release 5.9.0

.NET Unified API: New ITopicControl.Remove capability (15043)

New 'Remove' methods have been added to ITopicControl which will replace the old ITopicControl.RemoveTopics methods (now deprecated). The difference being that it is now possible to remove a topic without removing its descendant topics in the topic tree hierarchy.

.NET Unified API: Provide ErrorReason to identify handlers closed by exceptions in callback methods (15046)

Additional exception handling has been added around handler callbacks. When an exception is thrown by a handler callback method the handler will be closed and a notification passed to the handler's onError callback. The ErrorReason will be code 105, "An application callback threw an exception. Check logs for more information.". The log message ID PUSH-000628 has been added for these exceptions. Any exceptions thrown by the onClose or onError callback methods will be logged but onError will not be notified.

.NET Unified API: Delegated Topics and IStateProvider removed (15066)

Delegated topics and the associated IStateProvider mechanism in the ITopicControl feature were deprecated at release 5.1. These have now been totally removed from the product.

.NET Unified API: The deprecated Topics.GetStreamsForTopic() method has been removed (15212)

The Topics.GetStreamsForTopic() method has been removed. It was deprecated in Diffusion 5.7.0.

.NET Unified API: Pass IBytes instead of IContent for IUpdater.update method in ITopicControl (15252)

The IUpdater.Update method in ITopicControl now takes type IBytes instead of IContent. This means that the method can now be used for topics that have IBytes values (e.g IJSON, IBinary) as well as IContent based values.

.NET Unified API: Headers removed (15265)

The Headers type was deprecated in release 5.2 in favour of a simple list of Strings. Headers has now been removed.

.NET Unified API: SUBSCRIPTION_REFRESH reason (15270)

A new TopicUnsubscribeReason has been added to the Topics feature of the Java Unified API. TopicUnsubscribeReason.SUBSCRIPTION_REFRESH indicates the server has re-subscribed a session to the topic. Existing streams are unsubscribed because the topic type and other attributes may have changed. This can happen if a set of servers are configured to use session replication, and the session connected to one server reconnects ("fails over") to a different server.

Apple Unified API: Deprecate session error handler protocol (15173)

The PTDiffusionSessionErrorHandler protocol has been deprecated, replaced by the error property on the PTDiffusionSessionState class.

Apple Unified API: Deprecate updater's use of Content and replace with Bytes (15248)

The update methods on PTDiffusionTopicUpdater that took PTDiffusionContent have been deprecated, replaced by new methods that take PTDiffusionBytes. This means that they can now be used for topics with values deriving from PTDiffusionBytes (i.e. JSON, Binary and Content-based).

Apple Unified API: SUBSCRIPTION_REFRESH reason (15268)

A new value has been added to the PTDiffusionTopicUnsubscriptionReason enumeration. PTDiffusionTopicUnsubscriptionReason_SubscriptionRefresh indicates the server has re-subscribed a session to the topic. Existing streams are unsubscribed because the topic type and other attributes may have changed. This can happen if a set of servers are configured to use session replication, and the session connected to one server reconnects ("fails over") to a different server.

C Unified API: Propagate ErrorReason to clients (10641)

Service errors now propogate the error reason via the DIFFUSION_ERROR_T structure to the service callbacks, instead of a generic DIFF_ERR_SERVICE code.

C Unified API: Message loss detection (14441)

Message loss detection and reliable recovery via retransmission of missed messages has been added to the C API, bringing it to feature parity with other APIs.

C Unified API: Make diffusion headers C++ compatible (14527)

The main header file (diffusion.h) now conditionally declares C linkage to facilitate building with C++ compilers.

C Unified API: Additional events and information for session properties listener (14711)

Session properties listeners can now detect when sessions have been disconnected and are notified through the on_session_disconnect() callback. A new close reason, SESSION_CLOSE_REASON_FAILED_OVER has also been added.

C Unified API: SUBSCRIPTION_REFRESH reason (15267)

A new reason code has been added to unsubscription notifications. UNSUBSCRIPTION_REASON_SUBSCRIPTION_REFRESH indicates the server has re-subscribed a session to the topic. Existing streams are unsubscribed because the topic type and other attributes may have changed. This can happen if a set of servers are configured to use session replication, and the session connected to one server reconnects ("fails over") to a different server.

Classic API: Classic client APIs are deprecated (15194)

All Classic APIs for clients are deprecated: Java Classic API, .NET Classic API, Android Classic API, iOS Classic API, JavaScript Classic API, Flex Classic API, Silverlight Classic API. Instead of these Classic APIs use the Unified APIs. The Java Publisher API is not deprecated.

Configuration: Changed default value for the api-type element in the Connectors.xml (15418)

With the deprecation of classic APIs the default value of api-type in the Connectors.xml has been changed from 'classic' to 'all'. This allows both Unified and classic clients to connect to every connector by default.

Configuration: Element users in Managment.xml is optional (15421)

The users element in the Management.xml configuration file was previously deprecated but remained a required element with at least one child user element. This requirement has been removed, the users element is now optional and it does not need to contain any child elements.

Console: Improved console statistics - dropdown to select metrics instead of typing topic path (14765)

It is now possible to select metrics in the console using a dropdown instead of typing out the full topic path.

Java and Android Unified API: Headers removed (10872)

The Headers type was deprecated in release 5.2 in favour of a simple list of Strings. Headers has now been removed.

Java and Android Unified API: Improved CLOSED_BY_SERVER detection (14389)

An internal protocol change has improved notification to Java and Android Unified API clients that a session has been closed on the server. The client session will transition to CLOSED_BY_SERVER rather than RECOVERING_RECONNECT under more circumstances, avoiding unnecessary reconnection attempts. This protocol change will be included in the other client libraries in a future release.

Java and Android Unified API: New AUTHORIZATION unsubscribe reason (14836)

A new unsubscription reason (UnsubscribeReason.AUTHORIZATION) has been added which is used to report unsubscriptions due to a change in a session's assigned security roles.

Java and Android Unified API: TopicControl.Updater.update takes Bytes instead of Content (14958)

The Updater.update method in TopicControl now takes type Bytes instead of Content. This means that the method can now be used for topics that have Bytes values (e.g JSON, Binary) as well as Content based values.

Java and Android Unified API: Delegated Topics and StateProvider removed (15040)

Delegated topics and the associated StateProvider mechanism in the TopicControl feature were deprecated at release 5.1. These have now been removed from the product.

Java and Android Unified API: Provide ErrorReason to identify handlers closed by exceptions in callback methods (15047)

Additional exception handling has been added around handler callbacks. When an exception is thrown by a handler callback method the handler will be closed and a notification passed to the handler's onError callback. The ErrorReason will be code 105, "An application callback threw an exception. Check logs for more information.". The log message ID PUSH-000628 has been added for these exceptions. Any exceptions thrown by the onClose or onError callback methods will be logged but onError will not be notified.

Java and Android Unified API: The deprecated Topics.getStreamsForTopic() method has been removed (15211)

The Topics.getStreamsForTopic() method has been removed. It was deprecated in Diffusion 5.7.0.

Java and Android Unified API: SUBSCRIPTION_REFRESH reason (15266)

A new UnsubscribeReason has been added to the Topics feature of the Java Unified API. UnsubscribeReason.SUBSCRIPTION_REFRESH indicates the server has re-subscribed a session to the topic. Existing streams are unsubscribed because the topic type and other attributes may have changed. This can happen if a set of servers are configured to use session replication, and the session connected to one server reconnects ("fails over") to a different server.

JavaScript Unified API: New AUTHORIZATION unsubscribe reason (14838)

A new unsubscription reason (UnsubscribeReason.AUTHORIZATION) has been added which is used to report unsubscriptions due to a change in a session's assigned security roles.

JavaScript Unified API: JSONDataType.fromJsonString (14998)

The JSON datatype in the JavaScript Unified Client now provides a "fromJsonString" method, allowing instances to be created from a JSON string value.

JavaScript Unified API: New TopicControl.remove capability (15042)

Added TopicControl#removeSelector. This provides the ability to remove topics using TopicSelectors, permitting the user to qualify whether descendant topics should also be removed.

JavaScript Unified API: JSON Structural Delta (15112)

The JavaScript Unified API now provides the ability to derive JSON Structural Deltas from two JSON datatype values, via the JSON#jsonDiff method. Structural deltas allow the user to inspect removed and inserted values at a structural level, as well as determine intersecting or descendant changes for a particular path in the JSON object.

JavaScript Unified API: SUBSCRIPTION_REFRESH reason (15269)

A new UnsubscribeReason has been added to the Topics feature of the JavaScript Unified API. UnsubscribeReason.SUBSCRIPTION_REFRESH indicates the server has re-subscribed a session to the topic. Existing streams are unsubscribed because the topic type and other attributes may have changed. This can happen if a set of servers are configured to use session replication, and the session connected to one server reconnects ("fails over") to a different server.

Misc: Create an example MessageMerger for record topics with variable records/fields (14636)

An example MessageMerger for use in the conflation of record topics with variable records/fields has been added to the Diffusion install and Github examples.

Protocol: The DPT protocol is deprecated (14882)

The DPT protocol is deprecated, and will be removed in a future release. Applications should use the WebSocket protocol instead.

Publisher API: Topics may no longer be set as non-lockable (15079)

It is no longer possible to set stateless topics as non-lockable. All topics are now lockable and therefore TopicProperty.LOCKABLE no longer has any effect and has been deprecated.

Publisher API: Deprecate AuthorisationHandler.canSubscribe(Client, Topic) (15197)

AuthorisationHandler.canSubscribe() is deprecated in this release and will be removed in a future release. Prefer Diffusion's declarative role-based security.

Publisher API: Publisher Server Connections Deprecated (15198)

The ability to automatically connect publishers to other servers via PublisherServerConnections has been deprecated and will be removed at a future release. This was a form of classic client connection and classic clients have also been deprecated at this release. The main use for such connections was for manual fan-out. It is now recommended that the automatic fan-out feature is used instead.

Server: Subscriptions are re-evaluated when a session's assigned roles change (10669)

If a session re-authenticates with Security.changePrincipal(), the assigned roles associated with the session may change. Consequently the session may gain permission or lose permission to subscribe to topics. From this release, a session's topic selections are re-evaluated against the topics for which the session has gained READ_TOPIC permission, and the session will be unsubscribed from topics for which it no longer has READ_TOPIC permission.

Server: The maximum message size can be configured independently of input buffer sizes (11749)

The restriction that the input buffer size configured for any connector is at least as large as the maximum message size has been removed. From this release, the maximum message size can be configured to be larger than the input buffer sizes. This allows the input buffer size to be tuned independently. It is still good to set an input buffer size large enough to handle the majority of inbound messages. If a message larger than the input buffer size arrives, a larger buffer will be allocated and a warning logged.

Server: Improved topic selector cache management (14863)

Improvements to topic selector cache such that tidying occurs on a more regular basis.

Server: Reject unsupported service invocations (14881)

Allows the server and the Java client to detect attempts to invoke unsupported versions for a given client type and protocol version, and respond with an appropriate CommandError.

Server: Improve reliability of missing topic notifications (15001)

Improves the reliability of handling missing topic notifications. Where a common path is registered to multiple missing topic notification handlers, if one fails to handle it, another handler will be attempted.

Topics: Topic notify, paged, child list and custom topics are deprecated (15193)

Paged, topic notify and child list topics have been deprecated as they can only be used within the classic client APIs which have also been deprecated at this release. They will be removed in a future release. Custom topics have also been deprecated as in most cases support for other data types can be better achieved using Binary topics.

Unified API: The unused Session.State.RECOVERING_FAILOVER is deprecated (15119)

The RECOVERING_FAILOVER session state is unused. It is deprecated from this release, and will be removed in a future version of the product.

Unified API: Fallback streams subscription and unsubscription improvements (15271)

In previous releases, a fallback stream was not notified when a new stream was added that selected subscribed topics, when a stream that selected subscribed topics was removed, nor there were existing subscribed topics with no associated streams when the fallback stream was added. This led to inconsistencies. From this release, the client will generate synthetic subscription/unsubscription events for fallback streams. When a new stream is added, all fallback streams will receive an unsubscription for the topics the new stream selects, with the unsubscription reason STREAM_CHANGE. When the last stream applying to a topic is removed, all fallback streams will receive a subscription for the topic. When a fallback stream is added, it will receive subscription notifications for all subscribed topics that have no other associated stream.

Unified API: Relaxed parsing of split path and full path topic selector expressions (15275)

The parsing of split path and full path topic selector expressions has been relaxed a little. A single leading path separator is tolerated and ignored. Previously "?/x" would fail to parse; from this release "?/x" behaves the same as "?x". Previously "*/x" would not match the path "x"; from this release "*/x" behaves the same as "*x" and so matches the path "x". A single trailing path separator is tolerated and ignored. Previously "?x///" would fail to parse; from this release "?x///" behaves the same as "?x//". Previously "*x///" would not match the path "x"; from this release "*x///" behaves the same as "*x//" and so matches the path "x".

Bugs cleared at release 5.9.0

.NET Unified API: Messaging: correct handling of message that matches no streams (15345)

The handling of an inbound message that matches no streams has been corrected. In previous releases, if the session had never used the Messaging feature, the behavior was correct. However, if the session had used the Messaging feature but not added a stream matching the message or a fallback stream, the message would be discarded and successful delivery to the client would be acknowledged using the onComplete() method of the ISendCallback. From this release, the implementation has been corrected to match the documented behavior. The client will always reject an inbound message that matches no streams, and will log an INFO message. The server will log the rejection as a COMMUNICATION_FAILURE and report the delivery failure to the IMessagingControl sender as a failure using the onDiscard() method of the ISendCallback and the sending session's error handler.

Apple Unified API: Topic stream delegates not being told of failure on session close (15289)

Topic stream delegates are now sent a message, via their diffusionStream:didFailWithError: implementation, when the session is closed prematurely.

Apple Unified API: PTDiffusionSessionId description should be lower case (15315)

Session identifier descriptions now use lowercase hexadecimal in order to conform with other client implementations.

Apple Unified API: feature property exposed on stream interface (15385)

Removes the feature property from the PTDiffusionStream class. It was being unintentionally exposed.

C Unified API: Use connection response code to determine reconnection eligibility (14457)

The C API now correctly uses the response code from a connection attempt to determine whether it is valid to try reconnecting.

C Unified API: Use of error structure in session_create() and session_create_async() (14892)

Due to the lifespan of the session, the error parameter passed in the session_create functions could be reused during reconnection but the caller may believe that it is permissible to free the structure once the call has returned. The API will allocate memory internally for the error structure after the session_create call has returned and use that for future (automatic) reconnection attempts.

C Unified API: Reconnect may fail due to incorrect client state on server (15205)

Reconnection attempts which occur with a retry delay no longer attempt their initial reconnection immediately, but wait for the per-attempt retry timeout first.

C Unified API: SessionId.toString() should be lower case (15316)

session_id_to_string() now uses lowercase letters for hex digits a-f.

Demos: hot undeploy/deploy errors with publisher dars (14784)

Addresses issues with the Echo and Dogflight demo, and the Diffusion console when they are hot undeployed and deployed.

Java & Android Client: Client fails to initialise if the context classloader is set (15247)

The client library failed to correctly initialize from a thread with a context classloader that masked its resources. This problem was found during testing in an OSGi container. A code change has been made to use the appropriate classloader to load resources.

Java & Android Client: Wrong argument passed to logger for PUSH-000588 (15262)

The correct argument is now passed to the logger.

Java and Android Unified API: If a stream was added twice, it would be notified of session closure twice (15282)

If a subscriber stream was added more than once and the session closed, the stream would be notified more than once. This bug has been fixed in this release.

Java and Android Unified API: Messaging: correct handling of message that matches no streams (15342)

The handling of an inbound message that matches no streams has been corrected. In previous releases, if the session had never used the Messaging feature, the behavior was correct. However, if the session had used the Messaging feature but not added a stream matching the message or a fallback stream, the message would be discarded and successful delivery to the client would be acknowledged using the onComplete() method of the MessagingControl.SendCallback. From this release, the implementation has been corrected to match the documented behaviour. The client will always reject an inbound message that matches no streams, and will log an INFO message. The server will log the rejection as a COMMUNICATION_FAILURE and report the delivery failure to the MessagingControl sender as a failure using the onDiscard() method of the MessagingControl.SendCallback and the sending session's error handler.

Java and Android Unified API: JSON Deltas don't report empty fixed-length structures (15388)

The diff algorithm used by JSON Deltas incorrectly skipped empty arrays or objects that had been encoded as a CBOR fixed-length structure. This would manifest as empty structures not being included in reported changes (JSONDelta#inserted, JSONDelta#removed). This has now been fixed.

JavaScript Classic API: Receiving topic status messages in classic JS returns an error (15400)

Addresses an issue where an error was thrown when receiving a topic status message - this was due to an undefined variable. This has now been resolved.

JavaScript Unified API: JavaScript logging does not reset reconnection attempts after reconnection (14849)

The logging that reports the number of reconnection attempts made was not reset on successful reconnection. This meant that if the connection was lost again after reconnection the logging would report the cumulative number of reconnection attempts. This is now reset on reconnection and the logging reports the attempts since the last connection loss.

JavaScript Unified API: Conversation errors result in session close (14944)

In the JavaScript Unified Client, conversation set errors were incorrectly propagated to the session, resulting in session closure even if the error was recoverable. Conversation errors will now be logged without affecting the session state.

JavaScript Unified API: SessionID equality not obvious to determine (15318)

SessionId.equals() has been added which allows easy comparison of Session IDs.

JavaScript Unified API: Missing delivery information when sending a message to SessionFilter (15319)

When sending a message using session.messages#send to a SessionFilter, the value returned on successful completion did not contain the number of resolved recipients, or any delivery errors. This information has now been added.

JavaScript Unified API: SessionPropertiesListener.onError is missing (15323)

The SessionPropertiesListener interface was missing the "onError" method. This is necessary for errors within the listener to be correctly propagated to the user. Previously, errors would result in the client being closed with poor visibility on the root cause.

JavaScript Unified API: Fallback streams did not filter incompatible updates (15339)

In previous releases, updates for non-JSON topics could be routed to a fallback value stream registered to only receive JSON updates, e.g session.stream("foo").asType(JSONDataType); From this release, fallback value streams only receive updates for topics with compatible data types.

JavaScript Unified API: Session.messages.send should allow sessionid (15340)

Session.messages.send will now accept a SessionId object as well as a string as a target recipient.

JavaScript Unified API: Messaging: correct handling of message that matches no streams (15347)

The handling of an inbound message that matches no streams has been corrected. In previous releases, if the session had not added a stream matching the message or a fallback stream, the message would be discarded and successful delivery to the client would be acknowledged for the sender. From this release, the implementation has been corrected to match the documented behavior. The client will always reject an inbound message that matches no streams, and will log an INFO message. The server will log the rejection as a COMMUNICATION_FAILURE and report the delivery failure to the sender.

Logging: Logging bottleneck under memory pressure (14866)

When the server was running low on memory, the message catalogue could be evicted from memory causing a performance problem as it needed to be reloaded the next time a message was logged. This problem has been resolved.

Replication: Ensure that a HTTP polling client reconnects after failover (12273)

Clients using HTTP polling will now send a reconnect request after failover.

Replication: Update sources not changing state on server close (14721)

With topic replication enabled when two update sources for the same path are registered on different servers only one should be active. If the server with the active update source is shutdown or removed from the cluster it is expected that the standby update source will become active. This was failing in some cases as an incorrect representation was used to associate update sources with a server. This representation was not guaranteed to match the representation used when notifying of servers being removed from the cluster. This was leaving the updater of the removed update source as the active one for the cluster. This has been fixed by changing to a better representation of the server.

Replication: Update sources created before a new server joins might not be removed when the server it was registered on closes (14981)

New members of a cluster were not correctly associating update sources with the server that registered them. If the new member then mediated the removal of a member which registered update sources it would fail to remove them. Update sources that exist when a cluster is joined are now correctly associated with the server that registered them.

Server: Update source registration and close thread safety issue (12500)

A thread safety issue has been identified in server side registration and close of update sources. It caused a NullPointerException to be thrown during the close of update sources. This has been fixed.

Server: Conversation responses incorrectly ignored because of race condition (14968)

Beginning asynchronous operations at the same time in different threads could cause responses to one of the operations to be ignored. The could affect many things including adding topics from different threads at the same time. The race condition has been addressed.

Server: NullPointerException when a classic Java client connects with an empty credentials object (14980)

Addresses an issue where a NullPointerException was thrown when a client application provides a Credentials object with no username or password. The NPE is no longer thrown, instead an empty username or password is set in this case

Server: HTTP MessageChannels leak NetworkChannels with bad consequences for buffer pools (15353)

Management of secondary connections associated with HTTP pooling transport connections has been improved. This removes some possible buffer and file descriptor leaks.

Server: Possible buffer leak on close of SSL network channel (15407)

A rare byte buffer leak was fixed.

Unified API: Handling of invalid updates to JSON and Binary topics (15074)

If a client using the TopicUpdateControl has a stale cached value for a binary or JSON topic, an attempt to update the topic can fail with an UPDATE_FAILED error. The client can recover by removing its locally cached value and trying again. A bug in the error handling of stale updates could instead close the client session, logging an IndexOutOfBoundsException on the server. This bug has been fixed.

Unified API: Fallback streams registered to received JSON values did not filter incompatible updates (15337)

In previous releases, updates for non-JSON topics could be routed to a fallback value stream registered to only receive JSON updates - Topics.addFallbackStream(JSON.class, stream). From this release, fallback value streams only receive updates for topics with compatible data types.

Known Issues

.NET Unified API: Wrong exception thrown on custom topic selector implementations (16378)

If the topic selector implementation does not use the Diffusion API, an ArgumentNullException or a NulLReferenceException will be thrown instead of the expected ArgumentException.

.NET Unified API: IContent can not be used in IValueStream<T> (16483)

IContent can not currently be used as a valid type for a IValueStream<T> even though the API documentation states otherwise.

C Unified API: Issues with message loss on reconnect (14771)

Some message loss can occur when a client using the Diffusion C SDK reconnects to a server when using topics that deliver deltas (JSON, binary or record topics). It is also possible that a subscription notification can be lost on reconnect, leading to a fatal error causing the session to be closed. The recommended workaround is to avoid using reconnection with C clients, and instead to start a new connection.

C Unified API: Topic paths starting '@' cannot be subscribed to (17173)

If you are using the 5.9 C client with a 6.0 server, avoid creating topics with paths starting with '@'. Previously, topics with paths starting '@' were reserved for internal use and could not be created. This restriction is no longer enforced by the 6.0 server. The 5.9 C client library continues to use the internal topics, so topics with such paths should be avoided for interoperability.

C Unified API: WebSocket session open cannot be called concurrently (17786)

Due to an underlying issue in the libwebsockets library it is not possible to create concurrent sessions over WebSockets. This will be resolved in a future release.

Classic API: Topic Notifier Topic Data can produce duplicate initial selection events (17816)

A client can be notified twice if its selection matches a topic that has just been created.

Console: Console shows fractional users connected (15610)

The concurrent clients and client connections graphs on the console can display fractional users.

Console: The button to the console sometimes does not appear (15816)

The button to the console does not appear on the server dashboard under some circumstances.

Eclipse Tools: NPE if Introspector user doesn't provide credentials (17791)

The out-of-the-box configuration of Diffusion now mandates Introspector users have credentials.

Licensing: MAC addresses are not detected for inactive interfaces on Linux/MacOS (18050)

On Linux and MacOS, only running interfaces (with an IP assigned) can be checked for MAC address licences.

Logging: Cannot start Diffusion using log4j2 with JMX management disabled (17395)

It is necessary to make sure that management is enabled if you wish to use log4j for logging.

Publisher API: Rapid adds and deletes of topics can cause TopicTreeListener notifications to arrive out of order (15549)

Under some circumstances when the same topic is being added and removed very rapidly it is possible for the added and removed notifications to be delivered to the TopicTreeListener out of order. For example you may get several adds before a remove. Even the addition and removal of different topics when being done very rapidly may not notify in the exact order that the requests were made although this is only likely to cause an issue where processing of branch overlaps. Users should be aware of this possibility but there is no immediate plan to resolve this issue as the cases where it would have an impact are thought to be extremely rare.

Publisher API: TopicTreeListener notifications incorrect for topic detach/attach operations (15565)

Since release 5.9 it is possible to have unbound topic tree nodes created by the Unified API (i.e a node that has no topic). So when a hierarchic topic A/B/C is created then nodes A and A/B will have no associated topic. But for backwards compatibility when such a topic is created by a publisher then A and A/B will be stateless topics. The publisher API will see such unbound nodes as if they had a stateless topic, even though there is no usable topic at the node. For consistency when the Unified API adds a topic to an unbound node the TopicTreeListener is notified of a remove (the notional stateless topic) followed by an add (of the newly attached topic) and when a topic is removed from a node (as opposed to the topic branch being removed) then the TopicTreeListener is notified of a remove (the previous topic) followed by an add (of a notional stateless topic). The problem with this is that in both cases the remove notification suggests that the whole branch has been removed when in fact it has not. It would be more correct if the remove was notified on the TopicDeletionListener but the fact that these are different interfaces makes this impractical. This will be resolved in a future release by rationalizing the notifications into a single notification interface.

Server: Intermittent PUSH-000229 messages in logs (17016)

On rare occasions, when a Java client's session disconnects, the server logs a PUSH-000229 message with an IllegalStateException. This only occurs when a session is closing, and does not affect performance. If this message appears in logs intermittently and there are no other indications of a problem, it can safely be ignored.

Unified API: Record topics do not notify current value to TopicStreams (17695)

If the Topics feature is used to add a new TopicStream which covers record topics that have already been subscribed to, the stream will be notified of subscription to the topic, but will not be given the latest value for the topic, and will be unable to process subsequent deltas. For this reason, it is important to add the stream that will process a record topic before the topic has any subscribers.