To help diagnose query performance, a new configuration property showQueryPlan has been added to the TransactionLogTool which describes the execution plan for a query.

Implemented SELECT DISTINCT, which lazily yields DISTINCT rows by comparing each row against the rows previously seen.

When opening an executable transaction log archive it is now possible to specify '-e <extraction-location>' to indicate the directory will serve as the root for creating an extraction folder. This can be useful in cases where the archive contents should be extracted to a drive that is different from the working directory.

It is now possible to issue `set deletExtractedArchivesDirOnExit on` from within the Transaction Log Tool to specify that transaction log tool to clean up the extracted archive folder on tool exit.

With payload type mapping the TLT Query Engine no longer needs to deserialize an Entry's payload to query its type (Entry.object.class). This decreased a query of 2.1M records from 79 seconds to 14 seconds on average, a ~8% reduction in query time. Significantly, this savings only holds for queries that do not otherwise need to deserialize the Entry payload.

Also, in conjuction with XPLATFORM-555 which introduces field based type inference this can represent a significant savings for queries that operate on types that are not frequent in a transaction log and uniquely have a particular field because the tool no longer needs to deserialize a payload to determine if it has a field against which to compare against a value.

NOTE: This change required an upgrade of the guava collections dependency from 15.0 to 18.0, and truth.jar from version 0.13 to 0.23

This feature allows more efficient execution plans to be constructed under certain situations.

1. The WHERE clause of the query references multiple fields
2. These predicates are conjoined via AND rather than OR
3. Two or more of these fields are indexed

In this case the indexes may be read individually and their results hashed together to allow fewer rows of the underlying log to be read. E.g.

If both of the fields in the above WHERE clause are indexed then a hash join could be performed against their respective results, allowing fewer rows of the log to be read.

+This feature allows the query engine to inspect the fields that are queried and infer the classes to which they apply. E.g. a query such as

could be determined to only correspond to classes having these fields, and thus would be transformed into:

This "type inference" applies to any fields in any clause of the query. Note that in the above query the class Customer would be returned even though it does not have a 'salary' field because it has AT LEAST ONE of the fields present in the query.

Note that if any fields from Entry or Metadata are used in the query we will not be able to apply type inference because every records has these fields.

This can result in saving for between 15% and 70% of query run time because the class of an entry can be resolved without deserializing the entire entry.

Interactive tools such as TLT have been enhanced to allow using the set and get commands to set user properties instead of just configuration properties. This allows users to set and get property values of their own as well as reference System properties passed into the tool:

For example:

This release adds support for the generateArrayGetterEmptyIfNull option in the nvx-core maven plugin for Xbuf and Protobuf encodings generated by ADM. Specifying:

Will cause getters for array fields to return an empty array rather than the 'null' when the field is not set.

The Transaction Log Tool was updated with support for checkpointed State Replication Log's. When checkpointing is enabled, the underlying transaction log's filename is changed to included it's checkpoint version which necessitated changes in the Transaction Log Tool.

The transaction log tool has been enhanced with two new configuration properties to allow the user to control the timestamp format and timezone: timestampFormat and timestampTZ. These properties will be used for Date fields in dumped entries, and can also be used for parsing timestamps specified in queries.

See: http://docs.neeveresearch.com/display/KB/Transaction+Log+Tool+Command+Usage#TransactionLogToolCommandUsage-DatesandTimes
and http://docs.neeveresearch.com/display/KB/Querying+Transaction+Logs#QueryingTransactionLogs-DatesandTimestamps

For details.

This feature adds a new TLT config property filterUnsetFields that controls whether fields that have a hasXXX value will be filtered when the hasXXX method returns false

See http://docs.neeveresearch.com/display/KB/Transaction+Log+Tool+Command+Usage#TransactionLogToolCommandUsage-FilteringUnsetFieldValues for more information

This TLT feature allow controlling the json pretty printing settings for log entries that are dumped with the -d flag (e.g. json).

The following formats are available by setting the jsonStyle configuration property

• Default: Jackson default pretty printer
• Minimal: A minimal single line printer
• SingleLine: Single line with space after colon between field name and value
• Custom: Examines the runtime property nv.json.customPrettyPrinter to find the classname of a pretty printer that implements: com.fasterxml.jackson.core.PrettyPrinter

See http://docs.neeveresearch.com/display/KB/Transaction+Log+Tool+Command+Usage#TransactionLogToolCommandUsage-JsonStyleFormats for more information

Adds support for generating an isValid and getValidationErrors() on generated messages and entities to check for the presence of fields marked as required. Checks are made on primitive and embedded entity fields as well.

See http://docs.neeveresearch.com/display/KB/ADM+Message+Modeling#ADMMessageModeling-RequiredFieldValidation

Introduced the ability to mark string fields in an ADM Model as poolable. When a String field is marked as poolable a new type is created that extends XString, but can be pooled to eliminate garbage. Accessors on generated model objects follow semantics similar to those for embedded entity fields. For a full description of poolable string types see:

http://docs.neeveresearch.com/display/KB/ADM+Message+Modeling#ADMMessageModeling-PoolableStringTypes

To provide the basis for Pooled String types, RawString was deprecated in favor of new implementation com.neeve.lang.XString which has the same functionality, but is instead an extensible base class. To provide backwards compatibility, RawString was changed from an interface to a deprecated class that extends XString.

To support XString's independendent package structure a PktBuffer and PktIOBuffer were refactored to extend new base class implementations com.neeve.io.IOElasticBuffer and com.neeve.IOBuffer to allow buffer backing XStrings. This prompted deprecation of PktIOBuffer which had been used in previously generated code. While this change is backwards compatible, code regeneration is recommended to avoid deprecation warnings.

The x-adml.xsd schema has been enhanced to allow adding documenation to model elements that translate into javadoc in the generated code. Documentation can added in two ways.

Brief Documentation: Brief one line documentation can be added to a model by adding a doc="some description" attribute on the element.

Long Documentation: Multiline documentation can be added by adding a child <documentation> element whose content can be multiline and use javadoc supported html (when wrapped in a CDATA block)

The Application Data Modeler and XML parser has been enhanced to allow 'inlining' the fields of an embedded entity into another entity or message. Additionally support was added allowing a message's fields to be inlined into another. When a type is inlined into another type the inlining type will implement the inlined entity's interface if it has one.

The solace binding after startup invokes a validate() method defined on ISolValidator interface. The application user must implement this method and the classname of that method is specified as startup parameter "subscription_validator" on solace url. It is left to the application developer to decide what to do for validation check. The application developer can throw an untyped exception in case the configured subscription check fails or log and continue or just ignore the check.

Here is an example of how to specify validator parameter …

An example of validator

Documentation describing the Application Data Modeler's (ADM) Messaging features has been created outlining existing and planned functionality for the 1.9 release.

See http://docs.neeveresearch.com/display/KB/ADM+Message+Modeling

The Application Data Modeler and XML parser has been enhanced to allow defining reusable fields in a new <fields> section. See http://docs.neeveresearch.com/display/KB/ADM+Message+Modeling#ADMMessageModeling-Fields for detailed usage.

Adds the ability to query transaction logs on entrySize and payloadSize. The entrySize field is the serialized size of the entry included header data, the payloadSize is the serialized size of the entity or message that the transaction log entry contains.

An example query against these fields would be:

The Transaction Log Tool now accepts a '-i' command line option that is interpretted as a comma separated list of initial scripts to run prior to entering the main command processing loop in interactive mode, or before running a script specified by the '-s' option.

It is also possible to set the init scripts to run by setting -Dnv.tlt.initScripts to a comma separated list of scripts to run, though this value would be overwritten by a value specified by '-i' on the command line.

All the known properties used in either JCSMP and JNI binding have been rationalized, so no skipping property message would be emitted. However if any property is specified on solace url which is unknown to solace binding, warning message would be logged. An example of such warning in as below

<10,1644,Ironman> 20150228-14:35:28:627 (wrn)...MsgBusBinding<test.aeptest1> Unknown property 'vpn' specified, Ignorning ...

If the "single_session" property is specified for configuring the solace binding, the client for the session the binding will not create -IN and -OUT client named suffixed sessions in lieu of creating a single session.

• The ADM XML Parser now allows specifying the model 'name' as a model attribute. Prior to this change the model name was infered from the source xml file name. With this change the default name from the xml source file can be overridden to the one specified in the model's name attribute. This specified name is camel cased and used as the model name.
• The ADM XML Parser now parses a model's defaultFactoryId attribute and will use the factory with that id as the factory for model elements that don't specify a factoryId attribute.
• If the model doesn't define a factory with the default factory id, then a
  factory based on the model name will be created by camel casing the name and appending 'Factory' to it.

See http://docs.neeveresearch.com/display/KB/ADM+Message+Modeling#ADMMessageModeling-ModelElement

This feature implements a generateThrowOnUnsetGetters ADM directive which generates getXXXOrThrow() getter variants for message and entity fields. The getXXXOrThrow() methods throw an exception when accessed on a field for which its hasXXX() method returns false, and otherwise return the value of getXXX()

To make switching between the solace JNI and JCSMP bindings a more fluid process, rationalized, implementation agnostic, properties have been defined that can be used with either binding. For backwards compatibility, if the implementation specific property is used it will be applied to either binding implementation if specific, but users are encourages to use the rationalized property name. If non rationalized properties are used that are specific to a particular implementation, those properties will be passed through to the binding, and will produce a warning if, for example an unrationalized jcsmp.XXX property is configured and the JNI binding is in use (See XPLATFORM-752).

Here is final set of rationalized properties for JCSMP and JNI Binding

Provides the ability to create builder style 'fluent' setters when the generateBuilderSetters=true directive is set for the code generator. With this directive both

Are generated on the type implementation. At present support for these fluent setters do not support RawString types, Timestamps as Dates, or lend semantics. This may be added at a future date if warranted.

The fluent setters are intended for testing purposes only.

The code generator and Core X Maven Plugin were enhanced to allow code generator directives to be supplied.

See http://docs.neeveresearch.com/display/KB/ADM+Message+Modeling#ADMMessageModeling-Directives

Prior to this release, a Talon server continued to run even if all applications in the server had stopped. This release changes this behavior such that the server will automatically stop when all applications in the server have stopped. Setting the nv.server.autostop.onlastappstop system property to false will revert to the old behavior.

Prior to this release, an application could only receive server heartbeat messages via an AdminClient or a Robin controller. This release implements the ability for an application to receive server heartbeat messages (com.neeve.server.mon.SrvMonHeartbeatMessage) by registering an event handler for this message just as it would for any other event/message i.e.

All rules regarding message and embedded entity lifecycle that apply to regular messages also apply to the heartbeat message i.e. the application needs to acquire a reference to the message and/or embedded entities in case it desires to keep the message beyond the scope of the call.

Prior to this release, if a user wished to send alert or lifecycle events as messages on the wire, they had to hand craft these messages. This release introduces the alert and lifecycle ADM models that define messages that back the lifecycle and alert events. When an alert or lifecycle event is dispatched to the application, the application can use the getBackingMessage() method implemented by the method to fetch the backing message.

The models containing the messages that back the alert and lifecycle events are

• Lifecycle Model
  • com.neeve.server.mon.lifecycle.model.xml
• Alert Model
  • com.neeve.server.mon.alert.model.xml

Notes

1. The message backing an event dispatched by an AEP engine will be null if the AepEngine is created and managed directly by the user. For the backing message to be populated, the application must be managed by a Talon server. Therefore, the application should always check for the backing message being null before processing it.
2. The backing message is owned by the event that it backs i.e. the message is disposed when the event is disposed. The application should acquire a reference to the message if it wishes to own a reference to the message separate from the reference owned by the event

This feature allows creation of semantic types in ADM message modeling. Semantic types lend semantic meaning to the ADM Model's scalar types, and can be referenced directly as types in the model.

See http://docs.neeveresearch.com/display/KB/ADM+Message+Modeling#ADMMessageModeling-SemanticTypes for more information

It is now possible to specify a single dependency version for the X Platform family of products (Core X, Robin, and Eagle) using the new nvx-platform-bom:

For more information on Maven BOMs see: https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html#Importing_Dependencies

Prior to this release, applications interested in listening for alert and lifecycle events needed to register type specific handlers for each of the events they were interested in. This release introduces the ILifecycleEvent and IAlertEvent interfaces implemented by lifecycle and alert events respectively. The application can register a single handler using these interfaces as follows to listen for all lifecycle and alert events

Note: There are certain events that qualify as both lifecycle and alert events. These events implement both IAlertEvent and ILifecycleEvent and will be dispatched to both the handlers if registered

Prior to this release, there was no way to specify expected startup conditions for applications managed by a Talon server. Expected startup conditions could only be specified with AEP Engines explicitly created by the application. This release implements the following with regard to the configuration of an AEP engine's startup expectations

1. Startup expectations can now be configured in an AEP engine's descriptor.
2. The use of an AEP engine's start(expectations) method has been deprecated in favor of startup expectations being set in the engine's descriptor
3. The DDL has been enhanced to allow for startup expectations to be specified. This allows for startup expectations to be specified in a DDL based platform XML configuration file.

This change adds the implementation of IAlertEvent.getTriggeringMessage for the following event types.

• AepApplicationExceptionEvent
• AepOutboundLogExceptionEvent
• AepSendExceptionEvent
• AepUnhandledMessageEvent

Applications can utilize the return message to provide more detailed diagnostics of the message.

Prior to this release, the transaction log metadata was not replicated between primary and backup. With compaction enabled, this means that the live log number and CDC metadata was not replicated resulting in (1) the backup being out of phase with the primary with respect to log numbering (2) log scavenging never occurring on the backup and (3) CDC restart occurring from the beginning on failover. This story replicates the log metadata to address these issues. This involves (1) metadata being replicated and applied at the backup during backup initialization from the primary (2) replication of the primary's metadata and application of the replicated metadata to the backup during steady state replication (3) real time scavenging of logs on the backup during #1 and #2 and (3) enhancing the CDC processor to be able to navigate around missing logs (which can legitimately happen if cluster members are stopped and restarted across compaction boundaries). With this story, the primary and backup remain in lock step not only with respect to the content of the logs but also log numbering and other log metadata.

Note: Metadata replication does not occur for clusters that are not CDC enabled and with compaction disabled (since, with these settings, the metadata is effectively replicated by parallel writes to the logs).

This release add the ability to tag a talon server's SrvController with an external configurer. Applications can access the object as follows:

Applications that create Talon servers programmatically can set boostrap configuration with the following call:

This change removes the "Copy from the name of the Pooled String getter method generated by ADM:

becomes

This release introduces the ability to create factories for poolable string type factories introduced in XPLATFORM-873 in a generic fashion as illustrated below:

This enhancement adds a new serverHostName field to the SrvMonHeartbeatMessage emitted by a Talon server. The hostName is set with the value of:

This story implements a binary logger aka "blogger". A blogger is a simple, easy to use logger for binary data. The blogger is layered on top of a standalone ODS store. It inherits all the benefits of the store and the X transaction log i.e. zero-garbage, high performance, detached persistence, object replay, SQL based structured queries, compaction, CDC (i.e. tailing) and ICR (for decoupled replication to a remote node etc).

This feature introduces the ability to configure a server's discovery descriptor in x-ddl. This is accomplished with a new optional discoveryDescriptor attribute on server:

This improvement adds a VMConfigurer.configure(Inputstream is, ISubstResolver) signature that allows a user to pass in an input stream containing the deployment descriptor xml rather than a File which is useful for applications that supply the x-ddl from the classpath rather than the filesystem.

The x-ddl schema is now documented with comments on the elements and attributes and published to a web location with each release build. Additionally a comprehensive document describing it has been added to the knowledge base:

Schema Published: http://build.neeveresearch.com/core/schema/LATEST/x-ddl.xsd

Reference Document: http://docs.neeveresearch.com/display/KB/DDL+Schema+Reference

This feature add a new EmbeddedServer class to Core X which allows the bootstrapping and creation of an Embedded Talon Server in a fashion consistent with the logic used by a standalone Talon Server launched via com.neeve.server.Main.

For example if an application has a com.foo.MyConfigurer defined in META-INF/services/com.neeve.server.Configurer, and the talon server is launched standalone via

java -cp lib/* com.neeve.server.Main --name MyServer

The server can be equivalently launched in an embedded fashion using

The above code would:

• load the Configurer defined in the META-INF/services/com.neeve.server.Configurer
• call the Configurer.configure(args) with the args
  Unknown macro: {"--name", "MyServer"}
  allowing it to seed the configuration repository vi VMConfigurer, and initialize the environment.
• Assuming the Configurer return "--name" with MyServer, would load the SrvConfigDescriptor for 'MyServer' and create a SrvController for the server
• When start is called start the 'MyServer' server.
  TALON

This release replaces the current IAepCentralMessageHandler with IAepPredispatchMessageHandler and adds a IAepPostdispatchMessageHandler. This gives applications to do post dispatch message processing in addition to the pre dispatch processing that was enabled by IAepCentralMessageHandler previously.

AepEngine now has setPredispatchMessageHandler and setPostdispatchMessageHandler methods for setting these, and the setCentralMessageHandler api has been deprecated along with IAepCentralMessageHandler.

IAepPostdispatchMessageHandler is invoked only if all previous handlers before it completed successfully (including predispatch handler, normal and default handlers). If any of these throw an exception the engine will dispatch an AepApplicationExceptionEvent which can additionally trapped by an IAepPostdispatchMessageHandler if notification is needed in the event of an error.

This feature adds the capability to configure a bus manager to enqueue inbound messages into the engine's multiplexer in a non-blocking manner which can be useful in cases where an application that operates with message loops can cause a deadlock. In x-ddl this is configured with:

<app>
<messaging>
<bus>
<nonBlockingInboundMessageDispatch>true</true>
</bus>
<app>

and may also be configured programmatically on an AepEngineDescriptor via it's bus manager properties

This release allows channel keys to specify default values for variable components of the key by using ${propName[::defaultValue]} syntax. The default value is applied only if propName is not found in the message, KRT provided to the send call, or the KRT configured for the channel (the global KRT)

This release adds 'fluent' builder style method signatures to interfaces generated by ADM when the generateBuilderSetters code generation directive is set to try. Prior to this release builder style setters were only generated on the impls.

The ADM model and XML schema has been enhanced to allow access to both the default factory and model documentation via the API as parsed from XML:

The following enhancements have been made

• x-adml schema has been updated to allow using <documentation> child element for the model
• Add public AdmDocumentation getDocumentation(){} to AdmModel. This returns null if no documentation is specified for the model.

• Add public AdmFactory getDefaultFactory(){} to AdmModel. This returns null if the default factory was not used in the model.

  ADM

This release adds support for simplified server command handler annotations. Prior to this command methods annotations was done by specifying an AppCommandHandler annotation that indicated the command name, and the message signature had to take two parameters, the command name and an array of command arguments that it was left to the application to parse.

In this release this AppCommandHandler annotation is still supported, but applications may opt to use the following new annotations instead:

• com.neeve.cli.Command - replaces AppCommandHandler to mark a method as a server command.
• com.neeve.cli.Argument - applied to a method parameter to mark the parameter as an 'argument'.
• com.neeve.cli.Option - applied to a method parameter to mark the parameter as 'option'

For example an application may @Command annotated methods may use only primitive java types as parameters and return values. Some example commands are:

Because the the above Command annotation doesn't specify a command name, the command name is taken as the name of the message. The command can take no parameters and has no return type.

A more complex example would be:

In the above command, the command name is "echo" and can be invoked via robin with

or without the count option (to use its default value):

This release implements the lendXXX() accessor for String in ADM generated messages. The method accepts an immutable XString. The use of this method avoids an extra copy between the domain and the serialized form of messages on which it is invoked

Prior to this release, messaging waypoint latencies are computed as aggregate across all message types. This release adds the ability to configure the system to compute these latencies by message type. To enable latency computation and reporting by message type, set nv.msgtype.latency.stats=true

This feature allows elements and attributes defined in x-ddl platform.xml files to be overridden via properties supplied to the VMConfigurer via the ISubstResolver. Configuration overrides have been documented at:

http://docs.neeveresearch.com/display/KB/DDL+Schema+Reference

The ADM Code Generator has been enhanced to add an annotation on generated message and entity classes to allow the type's corresponding factory to be located.

Provides new registerIfNoConflct methods for store object and message factories that throw OdsFactoryIdConflictException and SmaFactoryIdConflictException respectively if an attempt is made to register a factory class with an id that conflicts with another factory. This doesn't change the default behavior of AepEngine.registerFactory() which still uses the old variant that overwrites an existing factory definition

This new feature introduces an <env> element to the x-ddl schema which allows XRuntime configuration properties to be specified in DDL. Properties defined in the <env> element are seeded into the X configuration repository along with the buses, apps and servers being configured. The Talon server loads these values into XRuntime.

See http://docs.neeveresearch.com/display/KB/DDL+Schema+Reference#DDLSchemaReference-EnvironmentConfiguration for more details.

Enable field syntax: "select Customer." as well as "select com/foo/Customer.". These are each semantically equivalent to "select Customer" or "select com/foo/Customer".

This release provides parity in functionality between Xbuf, protobuf and Json message reflectors in support of dynamic channel key resolution:

• First letter uppercase field name reflection: now all econdings support first letter uppercase reflective access to fields. E.g for a message accessor getMyField, it is possible to specify $
  Unknown macro: {MyField}
  (with an uppercase 'M') in a channel key.
• Though discouraged for performance reasons, it is possible to to specify nested fields in channel keys $
  Unknown macro: {MyEmbeddedEntity.MyStringField}
  .
• Support for reflection in Json encoded types.

Prior to this change transaction log ROG metadata fields dumped in the transaction log tool were displayed in the abbreviated form used for message trace (e.g. txnid instead of transactionId) rather than their bean accessor form. TLT now dumps the fields using their bean path names to make them consistent with query and describe syntax.

This change also change the format of entries dumped vi 'next -d', 'dump -d' or 'dump -s' to display the entries as a valid block of json so that the entry can be cut and pasted into a json viewer, and adds additional entry fields to trace.

The javadoc jar for nvx-core-all is now published to Neeve's nexus repository which provides Maven users with easier javadoc reference from within IDEs.

This release enhances MessageReflectors for Xbuf to allow zero garbage append operations of non nested fields' string values to another XString for the folllowing field types:

• boolean
• byte, short, int, long
• enumerations
• String
• Poolable String subtypes
• Currency

This makes it possible to do zero garbage dynamic topic resolution for against variable channel keys for values that come from a message's non nested fields.

Implement monotonic scanning as a query plan read step. This
enables more efficient reads of a repository when there are query predicates
restricting a monotonically increasing or decreasing field (e.g Entry.timestamp) and that field is not indexed. (Given a suitable index, an indexed read is preferred as it will perform better.)

This improvement adds a new autoindexLimit property to the Transaction Log Tool to limit the number of fields autoindexed per query (default of up to 5 fields). This avoids the situation in which an issued query with a large number of fields and autoindexing enabled can slow down querying. Fields considered for autoindexing are taken from the WHERE, Order By, Group By and SELECT clause in that order, in the order they are specified in that clause.

This release add support for displaying the version of the platform and user build against which ADM generated code was generated.

Trace can be enabled that displays this information in several ways:

• Set -Dnv.sma.trace=verbose to trace factory version information when MessageViewFactories are registered with the platform
• Set -Dnv.ods.trace=verbose to trace factory version information when StoreObjectFactories are registered with the platform
• Calling MessageViewFactoryRegistry.dumpFactoryVersionInfo(StringBuilder) or StoreObjectFactoryRegistry.dumpFactoryVersionInfo(StringBuilder) to collect information about all registered factories

See http://docs.neeveresearch.com/display/KB/ADM+Message+Modeling#ADMMessageModeling-RuntimeCompatibility

This change upgrades the solace version from 5.5.1 to 6.1.0 (JCSMP version 6.1.0.197, CCSMP Version 6.1.0.148).

Note that this also necessitated the following transitive dependency upgrades:

• commons-logging-1.0.4 -> commons-logging-1.1.1
• commons-logging-api-1.0.4 -> commons-logging-api-1.1
• commons-codec-1.3 - > commons-codec-1.6

Producing results for certain queries sometimes involves writing the data to a temporary storage area particularly in cases where large sets of entries need to be sorted. This fix resolves an issue in which clean up of this area could take a long time resulting in a subsequent query executing more slowly than it should.

The relevant files are now simply deleted. In current testing the time to clean up these temporary data structures is no longer discernible from TLT.

Queries that are against a single, indexed field can now be satisfied purely by reading the index. Because indexes are lighter weight than log files this results in a significant performance gain.

E.g.

select Order.orderNumber from logs where Order.orderNumber between 1000 and 1100

The namespace for x-adml.xsd has been updated from http://www.neeveresearch.com to http://www.neeveresearch.com/schema/x-adml. The schema is bundled in the platform jars and used to validate message model files. Any model files declared with the old namespace will therefore fail to validate until the xlmns attribute is updated to the new namespace

This improvement enhance the solace JNI binding to output the solace library version at startup to bring it in line with the JCSMP binding.

With the implementation of 'checkpointing', 'compaction' and CDC in Core X 1.8, the 'Checkpoint' startup expectation is incorrectly named for what it is intended. This story renames the 'Checkpoint' exception in AEP, ODS, ROG and PktRecoveryLog to 'LogEmptiness' since that is really what it is supposed to check for on startup

Note: This is a breaking change for applications that use the 'Checkpoint' startup expectation. The applications would need to change to use the renamed 'LogReadiness' exception instead

This improvement additionally dumps Solace session level stats along with other bus binding stats when bus binding stats are logged.

In case of bad message, the following action would be taken

1) Log the bad message id
2) Dispatch an UnhandledMessageEvent - And let the appropriate event handler deal with the message
3) Quarantine the message which means dispatching to "quarantine" best effort channel for administrative action on the message
4) Ack the message if the message was received on a guaranteed channel and don't ack if the message is received on best effort channel. If the message is acked the message will be removed from the solace queue

This improvement enabled cut through persistence when the solace JNI binding is used (translates to setting FLOW_FORWADING_MODE in the solace binding to "2")

Adds a getSerializedToNativeLength() method to xbuf generated embedded entities. This allows callers to allocate memory up front and/or do target buffer bounds checking.

This change adds reference counting related methods (acquire/dispose/getOwnershipCount) to embedded entities generated with Protobuf/Json encoding to provide api compatibility with Xbuf generated source.

Because Protobuf and Json embedded entities are not pooled the method implementations don't actually perform reference counting and as such will not trigger an IllegalStateExceptions related to reference counting. To allow applications to determine if reference counting is actually implemented for a type, an additional method isReferenceCounted() has been added across all encodings. When false is returned by this method the application should not expect validation of referencing counting for acquire/dispose calls, and can ignore the value of getOwnershipCount().

This change adds API parity for the embedded entity serialization methods that allow serialization / deserialization to a native memory address allowing. Prior to this change the native serialization methods were only generated for xbuf generated entities.

Additionally, this change adds an isBufferBacked() method to embedded entities, to allow applications to test if using native serialization would efficient. Because json and protobuf generated entities aren't buffer backed calling getSerializedToNativeLength() followed by serializeToNative() would result in the entity being serialized to an intermediate byte[] on each call. So applications may prefer to instead call serializeToByteArray(), and serialize the bytes directly to avoid the extra byte[] serialization.

In 1.8 the ability to cache the ids of matching transaction log enties in a temporary disk backed structure. The goal of this feature was to make subsequent rescan of results more efficient (particularly in cases where there the selectPreviewCount in the tool is non zero). However, further testing has shown that for some types of filtering steps this can be less efficient due to the I/O overhead of writing out the cached ids. Consequently, this 'optimization' has been disabled for query plan filter steps which can improve initial query result times significantly to queries that are not very selective of results.

Dump of json entries from the TLT has been made mode effiicient (dump observed to be 4000% faster in some tests)

Transaction Log Tool querying has been to avoid deserializing an entry's payload to to determine its type. The tool now inspects the binary factory and payload type values to look up the type without deserialization which can be a significant improvement for queries that filter heavily on type.

Impliment monotonic scanning as a query plan read step. This enables more efficient reads of a repository (transaction log) when there are query predicates restricting a monotonically increasing or decreasing field and that field is not indexed. (Given a suitable index, an indexed read is preferred as it will perform better.)

Improves TLT to disallow open transaction logs with the --repair flag and a read only open mode. Transaction logs cannot be repaired in read only mode as the repair operation requires writing to the repaired log. Prior to this improvement, a cryptic "Error executing 'open': null" would be displayed if stracktrace display is off.

Stuck alert events are now only emitted if the stuck condition has persisted through two stuck alert threshold checks. This prevents a 'false positve' alert from occurring in the case where an engine has been idle for more than the stuck alert threshold and a new transaction is started just before a stuck engine check is made. In this case, the previous logic would 'see' that there are incomplete transaction, and that the last completed transaction occurred beyond the stuck alert threshold, even though the newly started transaction may have just started.

The new check prevents such a situation, but can lead to a slightly increased time to detect a stuck engine (but still less than 2 stuck alert threshold periods)

This improvement removes the IAepEngineWatcher interface in lieu of emitting events. The ILifecycleEvent and IAlertEvent interfaces have been introduced to allow applications to register interest in these event types by declaring a single EventHandler annotated method. The following lists the current event types that implement those interfaces respectively:

LifecycleEvent

• AepBusBindingCreatedEvent
• AepBusBindingCreateFailedEvent
• AepBusBindingDestroyedEvent
• AepBusBindingDownEvent
• AepBusBindingOpenedEvent
• AepBusBindingOpenFailedEvent
• AepBusBindingOpeningEvent
• AepBusBindingUpEvent
• AepChannelDownEvent
• AepChannelUpEvent
• AepEngineActiveEvent
• AepEngineCreatedEvent
• AepEngineStartedEvent
• AepEngineStoppedEvent
• AepFlowCreatedEvent
• AepMessagingFailedEvent
• AepMessagingPrestartEvent
• AepMessagingStartedEvent
• AepMessagingStartFailedEvent
• AepStateCreatedEvent
• StoreLifecycleEvent
• StoreBindingFailedEvent
• StoreBindingRoleChangedEvent
• StoreMemberDownEvent
• StoreMemberInitCompleteEvent
• StoreMemberUpEvent

AlertEvent

• AepApplicationExceptionEvent
• AepOutboundLogExceptionEvent
• AepOutOfOrderSendCommitCompletionAlertEvent
• AepSendExceptionEvent
• AepStatsAlertEvent
• AepStuckAlertEvent

• AepUnhandledMessageEvent

  TALON

Currently property substitution by VMConfigurer and InteractiveTool supports the following syntax:

$subst(%propName::defaultValue%)

This feature additionally allows doing substitution in the form:

${propName}
or
${propName::defaultValue}

For backwards compatibility, the old style of substitution is performed first followed by the new substitution mechanism.

This change allows discovery and invocation of private and protected annotated methods for annotations in the following packages.

• com.neeve.aep.annotations
• com.neeve.server.app.annotations

This allows applications better control over what methods are exposed without having to resort to inner or anonymous classes to hide such methods.

In terms of precedence in contexts where an annotation can only be used once, publicly declared methods will be discovered first and will be preferred over a protected or private method signature unless specifically documented to behave otherwise.

Enhance the Talon Server's Main class to print out the version of the platform it is being launched from when the server is started in embedded mode. Prior to this change version information was only printed when running the server from a standalone distribution.

Additionally a static api was added to Talon server main class (com.neeve.server.Main) to return the ProductInfo that contains the product version:

This change enhances the nvx-platform-bom to include versions for artifacts with classifiers including:

• nvx-core-all:linux-x86-64:jar
• nvx-robin:nojre-0.0.0-linux-x86-64:tar.gz
• nvx-robin:nojre-0.0.0-osx-x86-64:tar.gz
• nvx-robin:nojre-0.0.0-win-x86-64:zip

Prior to this change user poms that use the above classifiers would have to set the version explicitly.

ADM documentation to the server monitoring Alert and Lifecycle models which add javadoc to the generated messages that back Alert and Lifecycle events when running in a Talon Server.

The following packages are now included in javadoc:

• com.neeve.server.mon.alert

• com.neeve.server.mon.lifecycle

  TALON

This release adds a backing message to the event AepApplicationExceptionEvent. The backing message is of type AepApplicationExceptionMessage and is populated for the event when running in a Talon Server

Fixes an issue in which poolable string types created based on a field's name can conflict with other types either declared in the model or in that are built in. A new directive was added called pooledStringFieldTypeNameSuffixPolicy which can take the following values:

• Always: With this policy, the pooled string type is always suffixed with String which greatly reduces the likely hood of a name conflict.

• OnConflict: with this policy the code generator will suffix the generated pooled string type name with 'String' when the name conflicts with another type:

  would yield a pooled string type of MyEnumString to avoid conflicting with the enum field

• None: With this policy field names are not suffixed, and it will result in a code generation error if a conflict is found. This policy is useful where the model developer want to proactively monitor for such conflicts, and perhaps declare the pooled string field as a semantic type in the <types> section.

Finally, an additional directive, 'pooledStringFieldTypeNameSuffix' was introduced to allow the user to change the type name suffix to a value of their choosing.

The javadoc for XString.Factory.PROP_INITIAL_LENGTH was clarified to indicate that the length refers the size of the backing buffer preallocated (as need to encode the string as UTF-8 encoded bytes). Note, that at present XStrings still only support string manipulation of ascii encodable characters, so in many cases the distinction is not important, but as XString do allow pass through transport of non ascii Strings this can still be an important consideration.

This release allows disabling optimized buffer management operations provided by the Neeve native kernel, and enhances support for sun.misc.Unsafe based buffer management which Unsafe has been shown to be faster in some cases.

Kernel based buffer management can be disabled by specifying:

When native kernel buffer management is disabled the platform falls back to Unsafe buffer management. Unsafe buffer management can, in turn, be disabled with:

In which case the system will fall back to traditional byte buffer and arrays based buffer management.

An AepEngine will display trace about what type of buffer management is enabled when config trace is enabled:

For applications not using an AepEngine lower level buffer management config trace can be enabled via:

which will print buffer management config to the console.

Prior to this release, the Solace binding supported performing the actual send of messages in a thread separate from the thread that performs serialization. However, it is the Solace runtime dispatch thread that does both receipt from Solace and deserialization. This release adds the capability to perform "detached" dispatch i.e. hand off the received message to a separate thread to perform deserialization. This separates the machinery that copies the serialized message out of the Solace runtime and the machinery that deserializes this serialized form into a message that is usable by the application. This has a considerable improvement in throughput performance.

The new descriptor parameters that control detached dispatch are as follows:

• detached_dispatch=true (default=false)
• detached_dispatch_queue_depth=numeric (default=128)

• dispatcher_cpu_affinity_mask=string (default=0)

  SOLACE BINDING

This change enhances the IllegalArgument thrown from an ADM generated enumeration's fromValue(int) method to include the illegal argument value in the exception text to make it easier to diagnose issues.

This improvement enhances the AepEngine message trace output displayed when nv.aep.msg.trace=true is specified to provide the same formatting options as the Transaction Log Tool. The trace options are not controlled as follows:

This change deprecates the 'nv.aep.msg.trace.full' property in favor of nv.aep.msg.trace.metadata above.

See http://docs.neeveresearch.com/display/KB/AEP+Engine+Trace for more details

This improvement allows for configuration of the cluster discovery descriptor to be specified in x-ddl outside of the main descriptor. Prior to this change configuring a unique discovery descriptor for the store was only possible by setting it in the store descriptor's address portion which didn't allow passing in additional discovery descriptor parameters.

Example:

This improvement allows reference tracking to be enabled for individual classes. Prior to this change reference tracking could only be enabled globally which results in too much overhead for some cases because it involves additional memory and introduces significant processing overhead.

Reference tracking may now be enabled as follows:

• Globally by setting the X Runtime property nv.reftracking.enabled=true
• Globally by setting the X Runtime property nv.reftracking.types=*

• On a type by type basis using nv.reftracking.types=fullclassname1[|fullclassnameN] (a list of fully qualified class names delimited by '|')

  ADM
  TALON

This change allows for the the properties 'nv.enablecpuaffinitymasks' and nv.defaultcpuaffinitymask' to be updated via XRuntime and take effect for newly created thread. This change is necessary because the affinitizer can be initialized prior to execution of an application's VMConfigurer.

This change ensures that messages sent with the new setAsPriority() flag set are sent in order with respect to previous messages sent in the same batch when adaptive batching is enabled.

Enhances the ADM XML Parser to provide an option to cache imported models. This improves parse times for applications that load models with large shared imports.

This release changes the XString interface into a concrete extensible based type which is a replacement for the RawString interface introduced in 1.8. RawString has been deprecated and applications should be updated to use XString in place of RawString in all locations where it was previously used. This change lays the ground work for allowing the introduction of XString pooling and extensible pooled String types.

Starting with this version, the ADM code generator now annotates code with an ADMGenerated annotation. This annotation allows the platform to validate runtime compatibilty of the generated source with respect to the platform.

See http://docs.neeveresearch.com/display/KB/ADM+Message+Modeling#ADMMessageModeling-RuntimeCompatibility for more detailed information

This release of X drop support for using the store's transaction log for outbound message logging. Consequently, the outbound message logging policy may now only specify UseInbound if the inbound message logging policy is set to UseDedicated (or Off). Note that in future releases, the notion of sharing a persister for inbound and outbound message may be dropped entirely, so users are encouraged to use separate persisters explicitly.

As part of performance related work the schema of the Transaction Log Tool indexes has changed between the 1.8 and 1.9 versions. It is possible to query 1.8 transaction logs with the 1.9 version of TLT, index files need to be deleted when switching between versions.

This release adds a schema version identifier to the indexers on disk. When 1.9 opens a 1.8 log it can detect that the indexes are out of date and automatically delete them. However, 1.8 is not able to do this check, so if you perform queries against using the 1.9 tool, the index files must be deleted manually before launching the 1.8 version of the tool.

This release updates the Solace JCSMP dependency version to 7.1.0.207 and the JNI CCSMP version to 7.1.0.227.

Prior to this release, events dispatched by an AEP engine would have a source as the root originating component e.g. store, bus binding etc. This release enhances the AEP engine to stamp itself as the source on all events that are dispatched by it. The following code would get the source engine for an event

This change enhances talon's app loader to check the thread context classloader for the class when it is launched in an embedded mode. The check for the context class loader is done before using the classloader that loaded the class to give the caller better control over classloading.

Because the server monitoring models (lifecycle, alert and heartbeats) are not artifacts that might be used directly by end user applications, this change bundles the model.xml in the built jars:

• com/neeve/server/mon/model.xml -> contains the server heartbeat model
• com/neeve/server/mon/alert/model.xml -> contains the alerting model
• com/neeve/server/mon/lifecycle/model.xml -> contains the alerting model

Prior to this change the generated poolable string accessors:

and

made it necessary to cast when supplying a null defaultValue for the default value accessor.
This change renames the generated getXXX(XString.Factory<T>) to copyXXX(XString.Factory<T>). This approach avoids the name clash ambiguity and also has the advantage of making it clear to the developer that this is a copying operation.

ADM models generated by the code generator should be included in the built jar so that components can introspect the model at runtime, because the presence of code generator directives external to the model may alter the model to some degree, the code generator now outputs a copy of the model in a namespace qualified path in the generated source output directory.

This release changes the default ADM pooledStringFieldTypeNameSuffixPolicy to be None. Prior to this release the default policy was OnConflict, which is less predicable and therefore an unsuitable default value.

See http://wiki.neeveresearch.com/display/KB/ADM+Message+Modeling#ADMMessageModeling-PoolableStringTypes

To avoid conflicts when two talon servers are launched within the same JVM and to ease debugging of thread dumps, the Talon server's main and IOThreads have been renamed as follows:

Prior to this release, the Solace binding defaulted the client name used when establishing the Solace session to "" if not specified by the user via the binding's connection descriptor. This release changes the binding to use the binding's user name as the default. For applications using the AEP engine, the engine sets the user name as the engine's name.

Prior to this release, the Solace binding defaults TCP_NODELAY to true. This is inconsistent with other configuration parameters that default to favor high throughput instead of low latency. This release changes the default for TCP_NODELAY to false from true.

Prior to this release, the Solace binding supported a configuration parameter named fail_on_bad_message that can be specified via the connection descriptor. The name of this parameter is not reflective of the behavior it invokes since setting this parameter to true will cause the binding to shut down if any fault is encountered during the processing of an inbound message prior that prevents the message from being enqueued in the app's AEP engine's inbound multiplexer. This release changes the name of this parameter to more accurately reflect the behavior that it invokes. The name of the parameter is now fail_on_inbound_message_handling_fault

This change drops support for quarantining message on an inbound message handling fault in the solace binding. Prior to this release a use could specify quarantine="true" in the binding url, and the binding would attempt to transmit the raw message in error on the "quarantine" channel.

In practice, this functionality was of limited use because often times in such cases the binding itself is in a bad state and not able to quarantine the message. Instead it is recommended that users declare an @EventHandler for UnhandledMessageEvent.

This miletsone removes generation of fluent setters are generated interfaces when the generateFluentSetters directive is enabled because it introduces too many possible type conflicts for the return type when a class implement multiple interfaces with the same field.

The ADM directive generateBuilderSetters has been renamed to generateFluentSetters. The old property name has been deprecated.

This change improves argument parsing in the Talon Server main class to abort the launch of the server if there are unrecognized arguments on the command line. Prior to this changed unrecognized arguments were silently ignored which can lead to error if the user makes a typo.

When a select statement is issue to the TransactionLogTool, the tool builds a query plan, but does not necessarily execute it. Instead it returns control to the user and attempts to give the user a sense of how expensive the query will be to execute (e.g. whether or not a full scan of the logs will be required, or an estimated number of entries that will need to be read to serve results). This change makes this clear to the user by change the display text from:

to:

This release changes UnhandledMessageEvent to extend AlertEvent and backs it with alert monitoring model message SrvMonUnhandledMessageMessage.

An UnhandledMessageEventis dispatched by a MessageBusBinding to notify that a received message could not be dispatched by the message bus binding. This is different from AepUnhandledMessageEvent (backed by SrvMon*App*UnhandledMessageMessage) in that the former indicate a failure prior to dispatching the message to the engine, while the latter indicates a failure after the message has been dispatched from the bus binding to the engine.

Some examples of situations that result in an UnhandledMessageEvent are:

• The message was corrupt and could not be deserialized into a message view.
• There was an exception processing the message in the bus binding.
• A Message was received on a channel that has not been joined.

The mapdb library was upgraded from 1.0.1 to 1.0.6 to resolve file locking issues on windows which resolves an issue where indexer files weren't deleted successfully.

Resolves an issue in which certain operations on a non existing transaction log file would result in a .metadata file be created even if the transaction log itself does not exist.

Resolves and issue in which the index size metric may not be reset correctly when divergence is detected between the index and transaction log which could cause the transaction log Query Engine to create inaccurate query execution plans.

If a query with an ORDER BY clause is executed via an index-ordered read of a relevant index this index must be fully populated. Previously there were scenarios where partially indexed field could inaccurately return less than the entire relevant result set.

Note that if auto-indexing is enabled a query may generate one or more indexes. If its execution plan uses one of these indexes and the indexingPolicy is set to FLUSH_ON_USE then the query will wait for the index to be populated before it returns its results. In testing against 2.1M entries this could take up to 195 seconds.

Addresses a memory leak in BestEffort delivery for the Solace JCSMP binding, introduced during the transition to a shared kernel between the JNI and JCSMP binding. BestEffort messages were being held in acknowledgement queue and not being cleaned up because BestEffort messages are not acknowledged by downstream entities. This fix avoids holding best effort messages in the acknowledge queue.

Resolves a timing issue in which an exception like com.neeve.query.QueryException: Record 60260352 has not been loaded. Can be seen when executing a TLT Query

Fixes a concurrent modification issue that manifests as an ArrayIndexOutOfBoundsException which can occur when removing a node from a State Replication state graph where the node itself has child nodes.

1) Added log message for Channel not found for inbound message with message with that particular message id and which topic the message was received on.
2) Treating this as a bad message and quarantine it

Resolves an issue in which a java.lang.Error thrown during Talon server initialization was not being trapped which made diagnosing startup issues difficult to diagnose.

If the query engine encounters a corrupt index file it will be
discarded and a new index file will replace it.

Prior to this change the logic to dump messages pending ack in a LoopbackBus queue only dumped the first message. This change enhances the dump logic to dump all messages which is more useful in a diagnostic context.

Allow ResultSet rows that are not record-based, e.g. an
aggregate row, to be dumped field-by-field.

Resolves an issue in AMD code generation with the <generateDefaultGetters>true</generateDefaultGetters> directive resulting in a interface compile error due to a missing JsonIgnore import.

This fixes a deadlock that can occur for a Talon Application running in a Talon Server with server stats enabled when the the server or one of its applications is stopped concurrently with the first stats collection interval.

Resolves a code generation issue with xbuf code generation of the setXXXAsLong method for an ADM Model that declares a String field as deprecated. Prior to this fix the code generated applied to @Deprecation annotations to the method which results in a "duplicate annotation" compile error.

Fixes a bug in seeding the platform's configuration repository from an x-ddl (platform.xml) descriptor that specifies multiple server IO threads and their affitinities.

Fixes an issue where an AepOutOfOrderSendCommitCompletion alert is dispatched when using mixed QoS. The logic that checks whether a send commit completed out of order now permits a BestEffort send to complete prior to a Guaranteed send which is a plausible scenario for many SMA providers.

This change only affects whether the alert is generated, the AepEngine still provides total commit completion ordering so if an outbound BestEffort message from transaction 2 is completed before transaction 1 which had a Guaranteed message, completion of transaction 1 and 2 won't complete until the ack for the transaction 1 comes back.

Prior to this release, the o2s latency metric was only computed if nv.aep.<app>.latency.stats was set to true. However, it should be computed if either nv.aep.<app>.latency.stats is set to true or nv.msg.latency.stats is set to true. This release fixes this bug

This fix resolves a severe bug that can occur when a primary engine that uses pooling (for example an engine configured to use optimizefor=latency or optimizefor=throughput) loses the connection to the backup.

<55,20477,perf5.neeveresearch.com> 20151005-19:44:36:114 (sev)...Multiplexer event handler [com.neeve.aep.AepEngine@45f7c030] faulted with error [java.lang.IllegalArgumentException: attempt to access a pool (method=put()) after it has been closed] on event {[event=MESSAGE, type=105, source=blackbird, owners=1, endOfBatch=true, delay=0, scheduledTime=0, dispatchTime=0, channel=xsim-orders, view=com.neeve.poc.electronic.messages.OMSNewOrderSingle, autoAck=true, local=true]} with the following stack trace:
jvm 1    | java.lang.IllegalArgumentException: attempt to access a pool (method=put()) after it has been closed
jvm 1    |      at com.neeve.util.UtlPool.putUnprotected(UtlPool.java:893)
jvm 1    |      at com.neeve.util.UtlPool.postWash(UtlPool.java:966)
jvm 1    |      at com.neeve.util.UtlPoolWasher.washAndPut(UtlPoolWasher.java:173)
jvm 1    |      at com.neeve.util.UtlPoolWasher.wash(UtlPoolWasher.java:187)
jvm 1    |      at com.neeve.util.UtlPool.put(UtlPool.java:1024)
jvm 1    |      at com.neeve.ods.impl.StoreMemberReplicationStatus.dispose(StoreMemberReplicationStatus.java:54)
jvm 1    |      at com.neeve.ods.impl.StoreCommitCompletionStatus.clearReplicationStatuses(StoreCommitCompletionStatus.java:47)
jvm 1    |      at com.neeve.ods.impl.StoreCommitCompletionStatus.reset(StoreCommitCompletionStatus.java:73)
jvm 1    |      at com.neeve.ods.impl.StoreCommitCompletionEvent.reset(StoreCommitCompletionEvent.java:94)
jvm 1    |      at com.neeve.event.Event.init(Event.java:327)
jvm 1    |      at com.neeve.event.Event.init(Event.java:18)
jvm 1    |      at com.neeve.util.UtlPoolWasher.washAndPut(UtlPoolWasher.java:172)
jvm 1    |      at com.neeve.util.UtlPoolWasher.wash(UtlPoolWasher.java:187)
jvm 1    |      at com.neeve.util.UtlPool.put(UtlPool.java:1024)
jvm 1    |      at com.neeve.event.Event.dispose(Event.java:294)
jvm 1    |      at com.neeve.event.EventMultiplexer.dispatchEvent(EventMultiplexer.java:349)
jvm 1    |      at com.neeve.event.EventMultiplexerSingleThreaded.dispatch(EventMultiplexerSingleThreaded.java:545)
jvm 1    |      at com.neeve.event.EventMultiplexerSingleThreaded.access$1300(EventMultiplexerSingleThreaded.java:33)
jvm 1    |      at com.neeve.event.EventMultiplexerSingleThreaded$CarrierEventProcessor.onEvent(EventMultiplexerSingleThreaded.java:392)
jvm 1    |      at com.neeve.event.EventMultiplexerSingleThreaded$CarrierEventProcessor.onEvent(EventMultiplexerSingleThreaded.java:385)
jvm 1    |      at com.lmax.disruptor.BatchEventProcessor.run(BatchEventProcessor.java:113)
jvm 1    |      at java.lang.Thread.run(Thread.java:745)
jvm 1    |      at com.neeve.event.EventMultiplexerSingleThreaded$ProcessorThread.run(EventMultiplexerSingleThreaded.java:225)
jvm 1    | Ignoring...

Fixed an issue with the TLT archive command. Issuing the command `archive -n mylog -m` was causing the main log to be added to the list of logs to be archived twice when no inbound log is present which caused the archive operation to fail.

This resolves a bug in which MessageBusBindingEvent.getMessageBusBinding was throwing a ClassCastException.

Addresses an issue in which message on a backup fails to start when using the solace message bus binding. In some cases solace may not immediately detect that the primary's connection has failed. This change adds two new connection properties to the solace binding to allow a backup instance to retry connections on failover:

The session open retries logic above is not specific to failover scenarios and are applicable to any solace binding in which they may be useful.

Resolves an issue in detached message loggers (inbound and outbound) in which reference counting errors introduced in application code can cause the detached writer thread to exit without properly failing the journaller, which in turn could block the main engine event processing thread.

This fix also covers a store's transaction log persister and ICR sender/receivers which share the same code and were thus also subject to a risk of hanging in the presence of reference counting errors.