This release updates the ADM code generator to generate a copy() method for ADM generated messages. The copy:

• Copies all of a messages fields, but not metadata or timestamps (with the exception of originTs). In other words the copy behaves as if a new message instance was created and each field from the source message into the copied message.
• A copied message is writeable even if the message it was copied from is read only unless the copied message is an Xbuf generated message set to use FrameFields of FrameContainer (for these cases the copy leaves the fields in the backing buffer making them unavailable for update).
• For Xbuf encoded messages the copy operation is zero garbage. The present implementation in XBuf essentially serializes the message to a buffer and wraps a new message view around that buffer. Future releases may be able to optimize this process further.

ADM code must be regenerated to generate the new copy method on Messages, but this change doesn't require that code be regenerated if the new copy() methods aren't needed.

At runtime, a check for whether the message implements com.neeve.sma.CopyableMessageView can be done to check if a generic MessageView supports copy.
Compatibility Notes:

Code must be regenerated to generate the new copy() methods on messages. All embedded entities used by the message should also be regenerated. Messages generated with older versions of the platform will continue to work with this version, but will not support copy().

This release provides the ability to configure Event Sourced application to replicate in parallel. When so configured, the inbound event is replicated to backups in parallel with application message processing. For applications with message processing times that are higher than the cluster round trip replication time this can eliminate the latency cost of replication for low latency applications.

To enable parallel replication set the replicateInParallel (https://docs.neeveresearch.com/display/KB/DDL+Schema+Reference#DDLSchemaReference-<replicateInParallel>) in the application's config.

This release add the ability to log server heartbeats to a transaction log. To enable heartbeat logging for a server add the <heartbeatLogging> element to the platform configuration descriptor:

Heartbeats are logged in a file titled <servername>-heartbeats which by default will end up in a server-heartbeats subfolder in the data directory. The directory can be overridden by specifying a storeRoot property in the logger (recommended to avoid logging heartbeats to the same disk as recovery data). Each time the server is started prior heartbeat logs are backed up to the same folder and suffixed with a time stamp.

See the DDL Configuration Document (https://docs.neeveresearch.com/display/KB/DDL+Schema+Reference#DDLSchemaReference-<heartbeatLogging) for more details

By default erialization and network write of the packetized form of a store commit entry was done by the committing thread - the application's message processing thread. This release provides the ability to hand this work off to a dedicated thread allowing the application to move on to processing the next event in the pipeline. This can improve throughput and latency substantially for performance sensitive flows, but comes at the cost of an additional thread.

To enable configure detachedSends (https://docs.neeveresearch.com/display/KB/DDL+Schema+Reference#DDLSchemaReference-<clustering) in the application's clustering configuration.

Prior to this release, network read, de-serialization of the packetize form of a store commit entry and dispatch of the deserialized object to the engine multiplexer is done by the network reader thread. This story introduced the capability to perform this activity by a dedicated thread as an experimental feature. This can considerably improve overall system throughput. The following parameters on the store descriptor control this functionality:

detachedDispatch

• "true" switched on detached dispatch functionality while "false" disables it. Default
• default=false

dispatcherQueueDepth

• Controls the depth of the detached dispatch queue
• default=1024

dispatcherCpuAffinityMask

• Specifies the CPU mask to which the dispatcher thread should be affinitized to
• default=0

dispatcherQueueWaitStrategy

• Specifies the dispatchers queue wait strategy. Permissible values are
  • Blocking
  • Sleeping
  • Yielding
  • BusySpin
• default=Blocking

The name of the dispatcher thread is "X-ODS-Native-Dispatcher-<storename>.<membername>

This release adds support for specifying LogEmptinessExpectation.NotEmpty as an expectation for an engine's store. When NotEmpty is specified startup will fail if the store doesn't have an existing transaction log with at least one entry in it.

As with the existing LogEmptinessExpectation.Empty expectation the expectation is only enforced on a primary store.

Example:

Properties defined in the 'env' section of an X-DDL document can be used in variable substitution elsewhere in the document. For example:

Properties defined in the 'env' section of an X-DDL document have the lowest priority of all configuration sources and can be easily overridden using system properties and environment vars. Properties defined in the 'env' section may reference other system properties and environment vars, but not other properties defined in the 'env' section.

This release introduces a System Property 'nv.native.suppressextraction' which when true, skips extraction of the native libraries for cases in which the user has already manually extracted them.

Note: This property must be set as a System Property as extraction of native libraries may occcur before the configuration subsystem and XRuntime has been initialized.

ADM code generator can bundle model XML file and IDL files with all their respective dependencies. Maven plugins enable this through new parameter generateModelBundle(default=false) and modelBundleOutputDirectory (default=target/nvx-adm-model-bundle...)

This provides a simplified API for sending messages via an injectable message sender class.

This provides a simplified API for State Replication apps to access state by allowing them to declare event handlers that accept the application's state graph.  

Prior to this release, the following AEP engine configuration parameters could only be set via X runtime environment variables. This release adds these parameters to the engine descriptor and DDL

• Perform duplicate checking
• Perform midstream initialization validation
• Enable sequence number trace
• Enable event trace
• Enable transaction trace
• Enable schedule trace
• Enable message trace
• Set whether message trace should be in JSON or not
• Set JSON message trace style
• Set message trace metadata display policy
• Set whether to filter unset fields in message trace
• Set the maximum number of environment providers
• Enable send commit completion sequence alerts
• Capture message type stats
• Capture transaction latency stats
• Capture event latency stats
• Replicate in parallel

See DDL Application Configuration

This release allows more efficient transfer of repeated primitive fields for Xbuf encoded messages by introducing support of bulk copying of serialized backing bytes when transferring from an inbound message or to application state.

See: Repeated Field Bulk Copies
Compatibility Notes:

This change bumps the ADM Compatibility Level from 3.2.0 to 3.4.0 meaning that code generated with this version cannot be used with prior versions of the platform.

The ADM code generator has been enhanced to provide the option of incremental code generation for faster build times. This is the default mode. Source code won't be re-generated on each build unless model XML file or some of its imports changed. Maven plugin(s) can control this through incrementalBuild configuration parameter.
To disable new ADM code generator change detection mechanism, useBasicDeltaDetection configuration parameter can be set to true.

This feature causes some additional metadata to be written to the generated source folder root to track model changes.

This release improves synchronization of large transactions to a backup by negating the need to queue up transactions from a transaction log prior to replicating them to a backup. This

Prior to this release, the trace that is output by a failure to start recording on an environment provider is different from the trace output on a failure to stop recording on an environment provider. This release rationalizes both to be treated in the same fashion by wrapping exception in a RuntimeException with the detail message:

"Application ('<enginename') environment provider faulted with error [" + e.toString() + "] on transaction commit."

The resulting exception is handled as an unhandled event loop exception in the engine which results in the engine being stopped with the RuntimeException as the cause.

Prior to this release, if a waypoint listener throws an exception, it was treated in the same manner as when platform code throws a runtime exception i.e. treated as a fatal error. This release changes this behavior to not treat exceptions thrown by a waypoint listener to be fatal but rather to trap the exception, log it and continue

Prior to this release, X supported validation of a maximum resolved message key length when nv.sma.maxResolvedKeyLength was set to a value greater than 0. When set this would validate the length of a resolved key that had variable components (such as ORDERS/${Region}) but not for static channel keys. Otherwise, if the validation was not done during dynamic key resolution and the key length exceeded the maximum length supported for a messaging provider, then it was up to the provider to validate and throw the exception at the time the message is actually sent (which occurs after return from the message handler of the application that sent). Since the key is provided by the application and key substitution is performed using application supplied configuration, a resolved message key of an invalid length is technically an application exception and should be handled per the AppExceptionHandlingPolicy.

This release adds a validation of the resolved message key length when the environment property 'nv.sma.validatemessagekey=true'. This validation is performed during the AEP engine's sendMessage() method and is done regardless of whether key is static or dynamic. If the validation fails, the method throws a runtime exception back to the application. As long as the application lets this exception be thrown back from the message handler from where sendMessage() was invoked, X will handle the exception using the AppExceptionHandlingPolicy.

The validation performed on message key length validates the length of the key against the global max key length specified by the environment property 'nv.sma.maxresolvedkeylength' or the key length supported by the binding itself. For example, the Solace binding only supports a max key length of 250 characters so even if 'nv.sma.maxresolvedkeylength' is not set that limit will be enforced. Otherwise if 'nv.sma.maxresolvedkeylength' is set and is less than 250 characters then that limit will be enforced instead.

The default value for nv.sma.validatemessagekey is false. If not specified and nv.sma.maxResolvedKeyLength=true then the former behavior of only validating the key for variable channel keys still applies though it is deprecated and may be removed in a future release.

See Also:

• MessageChannel.PROP_VALIDATE_MESSAGE_KEY
• MessageChannel.PROP_MAX_RESOLVED_KEY_LENGTH

Prior to this release, X validated that channel key substitution did not yield empty channel key levels when nv.sma.allowEmptyKeyField was not set to true, but this validation was only performed for channel keys that had variable components. Otherwise, if the validation was not done during dynamic key resolution and the key contained empty levels then it was up to the provider to validate and throw the exception when the message is actually sent which occurs after return from the message handler of the application that sent the message. Since the key is provided by the application and key substitution is performed using application supplied configuration, a resolved message key with an empty level is technically an application exception and should be handled per the AppExceptionHandlingPolicy.

This release adds a validation checks for empty channel key levels for all channel keys when the environment property 'nv.sma.validatemessagekey=true' unless nv.sma.allowemptykeyfield=true. This validation is performed during the AEP engine's sendMessage() method. If the validation fails, the method throws a runtime exception back to the application. As long as the application lets this exception be thrown back from the message handler from where sendMessage() was invoked, X will handle the exception using the AppExceptionHandlingPolicy.

The default value for nv.sma.validatemessagekey is false. If not specified and nv.sma.allowemptykeyfield=false then the former behavior of only validating the key for variable channel keys still applies though it is deprecated and may be removed in a future release.  

See Also:

• MessageChannel.PROP_VALIDATE_MESSAGE_KEY
• MessageChannel.PROP_ALLOW_EMPTY_KEY_FIELD

This release implements the following performance improvements to the ODS store.

• Replace the use of read-write locks with lock free concurrency mechanisms.
• Reduce buffer copies in serializing commit packets.
• Faster data structures.

This release adds the ability to initialize and append to an XString using byte arrays:

See:

• XString.setValue(byte\[\]) (http://build.neeveresearch.com/core/javadoc/SNAPSHOT/com/neeve/lang/XString.html#setValue(byte\[\]))
• XString.setValue(byte\[\], int, int) (http://build.neeveresearch.com/core/javadoc/SNAPSHOT/com/neeve/lang/XString.html#setValue(byte\[\], int, int))
• XString.setValue(char\[\], int, int) (http://build.neeveresearch.com/core/javadoc/SNAPSHOT/com/neeve/lang/XString.html#setValue(char\[\], int, int))
• XString.append(byte\[\]) (http://build.neeveresearch.com/core/javadoc/SNAPSHOT/com/neeve/lang/XString.html#append(byte\[\]))
• XString.append(byte\[\], int, int) (http://build.neeveresearch.com/core/javadoc/SNAPSHOT/com/neeve/lang/XString.html#append(byte\[\], int, int))
• XString.append(char\[\], int, int) (http://build.neeveresearch.com/core/javadoc/SNAPSHOT/com/neeve/lang/XString.html#append(char\[\], int, int))

When <model> tag in ADM model XML has incorrect xmlns attribute, a better human-readable error will be displayed instead of default cryptic W3C error code "cvc-elt.1".

This release enhances Talon to record stats for the number of acks sent upstream by a message bus binding for inbound messages. The new statistic is now printed along with aep engine stats trace and emitted via server heartbeats.

The following is example of engine stats trace with new Acks line:

[Bus Manager (myapp.mybus)]
In.........{
...Msg{10,000,000(0) 0(0) 0(0) 0(0) 0(0) 0(0) 0(0)}
...Ack{10,000,000(0) 0(0)}
...Pkt{0(0) 0(0)}
...Stab{10,002,734(0) 0(0) 0(0) 0(0) 0(0)}
}

The 'Ack' line takes the format of <acksSentTotal>(ackSentInterval)(ackRateTotal,AckRateInterval)

Additionally, server heartbeat SrvMonAppBusBindingStats have been change to add a new numSentAcks field that reports the number of acks sent through a bus binding.

This release introduces new diagnostic trace to detect cases where the runtime environment is accessed prior to it being initialized with the full set of platform configuration. This is particularly helpful for customers that use ther own configuration mechanisms to initialize the runtime, because in that scenario it is possible that some platform components may be initialized prior to such configuration being applied.

The new diagnostic options must be enabled with the following properties being set as System properties on the process' command line or as environment variables by replacing the '.' with '_'.

For the most up to date usage of these constants:
See also: UtlConstants Javadoc

This release changes the timestamps returned by UtlTime.now() to represent the number of microseconds since the Epoch (1970-01-01 UTC). This allows such timestamps to be more meaningfully displayed as a date string and allows them to be better compared against System.currentTimeMillis(). As a measure of the number of microseconds from the epoch the timestamp only has millisecond resolution and is based on the resolution supported by System.currentTimeMillis(). The delta timestamp between subsequent calls remains at microsecond level resolution.

Returning epoch relative time is controlled by the property nv.time.useepochoffset=true|false. The property can be set to false to disable epoch based timestamps.
Compatibility Notes:

UtlTime.now() now returns the the microseconds since the Epoch. In prior releases with native time disabled ... the timestamp was returned as System.nanoTime() / 1000. With this change, this will no longer be the case.

ADM code generator plugins will rewrite model XML that is output to target/classes. Directives will be persisted to include any external directives passed directly to plugin. Model namespace will be persisted as well if namespace is overridden (by setting it through plugin). New XML is formatted with readable indentation, but some white space from original XML may not be preserved.

Prior to this release, the X Platform interpreted <NVROOT>/conf/platform.xml or <NVROOT>/conf/xplatform.xml as DDL based platform configuration files. This story adds <NVROOT>/conf/config.xml and <NVROOT>/conf/descriptor.xml also as valid DDL based platform configuration files. config.xml takes precedence over_descriptor.xml_ which precedence over the other two filenames.

Prior to this release, detached store persistence was enabled by default. This release changes it to be attached by default.

Prior to this release, the application autoStart parameter in the DDL was false by default. This release changes it to be true by default.

Prior to this release, the affinity of a IO thread of an XVM defined in a DDL was not set. This release defaults it to "0"

Prior to this release, the AEP engine's disposeOnSend configuration parameter defaulted to false. This release changes the default value of this parameter to true

Prior to this release, lockless pool concurrency was automatically enabled if and only if thread affinitization is enabled. There are situations in which a user would want to switch on lockless pool concurrency event when not switching on thread affinitization e.g. for zero garbage operation. This release adds a new configuration parameter, nv.pool.enablelockfreeconcurrency, that, if configured (to true or false), will take precedence over using thread affinitization as the means to determine whether lockless pool concurrency should be enabled or not.

Prior to this release, native IO was enabled for links when nv.optimizefor=latency unless the user explicitly set the nativeio property on the link descriptor. This story sets native IO to be true also when nv.optimizefor=throughput (unless set on the link descriptor in which case that continues to take precedence)

This release enhances the Solace binding to validate that the resolved message key length does not exceed 250 characters during send calls when nv.sma.validatemessagekey is set to true. This validation is done in addition to the existing validation based on the value of nv.sma.maxresolvedkeylength which will apply when set to a value less than 250.

This release improves the solace binding to set tcp_no_delay to true when the nv.optimizefor=latency, and to false when nv.optimizefor=throughput unless a value is explicitly set in the binding descriptor.
Compatibility Notes:

With this change it is no longer necessary to set tcp_no_delay if the above auto tuning is in effect.

As of this release the AepEngine will not emit an AepEngineStoppingEvent prior to stopping the engine. This adds greater visibility into the engine lifecycle and is also can be used by an application to augment handling of whether channel joins are preserved.

See Also: Aep Engine Lifecycle
Compatibility Notes:

Applications that declare handlers for IAlertEvent or ILifecycleEvent should consider whether additional processing is required for this event.

This release introduces the ability to configure an application's messaging and state factories via DDL. Prior to this change applications using Talon directly were required to programatically register such factories.

See Also:

• DDL message factories (https://docs.neeveresearch.com/display/KB/DDL+Schema+Reference#DDLSchemaReference-<factories>)
• [DDL state factories|https://docs.neeveresearch.com/display/KB/DDL+Schema+Reference#DDLSchemaReference-<factories>.2
• AepEngine.registerFactory()

This release allows setting the AppExceptionHandlingPolicy in DDL config for example:

Note that setting the app exception handling policy programatically on the engine or its descriptor will override the value specified in DDL.

Prior to this release, the AEP engine did not output whether detached pool washing is enabled or not in its config trace (i.e. when nv.aep.trace=config). This story adds this additional information to the engine's config trace

This release adds a new configuration option to an AepEngine to allow the application to control whether channel joins are preserved on shutdown. The engine's default behavior on graceful shutdown is to "leave" channels meaning underlying subscriptions are removed ... this new configuration property allows this behavior to be changed.

See:

• DDL: preserveChannelJoinsOnStop (https://docs.neeveresearch.com/display/KB/DDL+Schema+Reference#DDLSchemaReference-<preserveChannelJoinsOnStop>)
• Javadoc AepEngineDescriptor.setPreserveChannelJoinsOnStop

The behavior set for preserveChannelJoinsOnStop can additionally be overridden at runtime by setting a different value on the AepEngineStoppingEvent (See AepEngineStoppingEvent.html.setPreserveChannelJoins).

Prior to this release, a user could only set network link trace level at a global level by using X/SLF4J mechanisms to configure the trace/logging level for the nv.network.link logger. This release adds the ability to set the trace level using the "trace" link descriptor parameter.

For application cluster replication links, this parameter can be included in the <linkParams> element of the application store's <clustering> element in the X DDL configuration file. For example, the following sets an app's cluster replication link's trace level to config.

Prior to this release, a user could only enable network link statistics trace at a global level by setting the nv.link.network.stats.interval parameter to a positive value (indicating the interval at which link stats are output to the nv.link.network.stats logger). This release adds the ability to enable statistics output and set the statistics output frequency using the "statsinterval" link descriptor parameter. Once enabled, the network link will output statistics to the nv.link.network.stats trace logger.

For application cluster replication links, this parameter can be included in the <linkParams> element of the application store's <clustering> element in the X DDL configuration file. For example, the following enables and sets an app's cluster replication link's statistics output interval to 1 second.

This release improves ADM generated source to include @Deprecated annotation in addition to the the javadoc annotations which avoids compiler warnings.

Prior to this release if the direct binding was not configured with stampiots=true in its descriptor preWireTs and postWireTs would not be populated, this release additionally enables wire timestamp capture when nv.msg.latency.stats=true is enabled making allowing the full set of latency statistics to be computed.

This release enhances the Direct Binding to emit UnhandledMessageEvent to emit UnhandledMessageEvents in the same manner as the platform's other built in bus bindings.

This release improves the Solace binding to append channel and topic name to exceptions related to subscribe and unsubscribe operations to make issue easier to diagnose.

This release provides javadoc for the com.neeve.util package which contains some utilities that are pertinent to the end user. Not all apis in the util package are intended for use by end users, so users should check the class level javadoc to check if APIs are supported prior to using them.

Prior to this release, the act of instantiating a discovery cache automatically opened the cache too. This prevented the use case where a user could create and open a cache and just tap into the event stream to obtain the full, lossless picture of what is happening in the cache. This is because event handlers could only be created after the creation of the cache which was too late since events could start streaming in immediately after create completes. This release provides a mechanism by which the user can decouples the creation and opening of the cache to allow the act of create->addEventHandler->open to get all events happening on the cache without loss

Prior to this release, a user of a discovery cache could only get the entity added to the cache after the addition is complete. There are situations where a user would like to know the entity before addition to the cache. To support this requirement, this release implements the create() method that creates a new DiscoveryEntity and a add() that accepts discovery entity for addition. This allows for a user to get a reference to the entity before it is added to the cache

Prior to this release, the ODS store automatically opened the store during creation and provided a flag to override that behavior. This release discontinues support for this flag and, by default, does not open the store during create. This means that direct users of the store API must create the store and then explicitly open it

Prior to this release, the discovery cache returned IllegalStateException if a method is invoked on a closed closed cache. During JVM shutdown, it is possible for the JVM shutdown hook thread to close the cache while other threads are concurrently accessing the cache. The other threads do not expect the cache to be closed and so the IllegalStateException results in an ugly stack trace. This occurs particularly in the ODS store when JVM shutdown occurs while store membership changes are in progress. This release adds a new exception to the discovery cache - EDiscoveryJVMShuttingDownException - that the store traps and ignore thus eliminating the stack traces.

This release enhanced the loopback bus binding to ensure that message queued for a client are removed when a loopback channel is left and later rejoined. Prior to this release it was possible for messages queued prior to leaving the channel would be redelivered on subsequent rejoin.

This release enhances the transaction log to create a diagnostic dump to a temporary file when corruption is detected. This file can be used by Neeve support to diagnose issue related to transaction log corruption.

...Corrupted packet dump written to /temp/PktLogCorruption7801847786289107932.dump
Failed to open '/usr/local/myapp/rdat/myapp': 8
...***** Recovery log 'C:\temp\XPLATFORM-1428\rdat\market.log' is corrupt [com.neeve.pkt.log.EPktLogCorruptException: 8].
...***** ...[preamble=[ver=1 checkpoints=0], recoverableEntries=9909, recoverableLength=4111137]

Note: This dump will be emitted even in cases where transaction log corruption can be repaired by setting repair flag on the transaction log being opened. In many cases such 'corruption' is harmless: there is always the chance that an ungraceful shutdown of an engine will leave partially written records at the end of a transaction log which is not a cause for concern for a properly configured application.

This release adds the following additional stats to server heartbeats for an engine's input event multiplexer:

• scheduleQueueSize: the number of events scheduled and awaiting dispatch
• maxConcurrency: the maximum number of feeder queues for the multiplexer
• lastDecongested: the index of the last feeder queue decongested.

See: ISrvMonAppEventMultiplexerStats

This release changes Talon Server startup to display the X License details at launch:

This can be suppressed by launching the server with -Dnv.license.hide=true.

This release provided the ability to affinitize the solace reactor (receiving I/O thread) on the first message receipt. To affinitize the consumer thread specify "consumer_cpu_affinity_mask=n" on the bus binding descriptor url.

In addition, and regardless of whether or not the thread is affinitized, the name of the thread will be suffixed with X-SMA-BusName to make it easier to correlate to a given message bus. If the binding is not configured to use a single session then the thread suffix will additionally include "-IN" or "-OUT" to distinguish between the two sessions.

This release adds support for injecting a message into an engine with a delay. Prior to this release injecting a message into an engine could be accomplished using the multiplexMessage methods on the engine. This release deprecates the multiplexMessage methods in favor of the new injectMessage methods.

See: AepEngine.injectMessage
Compatibility Notes:

This release deprecates the AepEngine.multiplexMessage methods in favor of AepEngine.injectMessage methods. Applications that use these methods should change to use injectMessage instead.

This release improves the Stats Dump Tool to dump both interval and running stats for series (latency) stats to allow better interval based analysis.

This release improves stats dump tool output to prefix GC stats with "GC: " to make it clear that it is GC stats being shown and additionally prints the collector name for each set of stats on its own line to facilitate better grepping based on the collector name.

This release implements a code gen time check in the ADM Code Generator to test if an imported model was generated with a different encoding type than the the importing model. This check is only enforced if the imported model is resolved from the classpath and was generated with 3.4 or newer.

Prior to this release, the AEP engine sets messages as read only after return from the message handler. This means that a message can be modified in the event handler. This, in turn, implies that the message replicated to the backup will be different from the one processed by the primary. This is a serious issue since it can cause divergence. The AEP engine was modified in this release to set a message as read only before dispatching the message to the central and message specific handler. This change is for Event Sourcing and State Replication

It is possible to disable marking inbound messages as read only by setting nv.aep.inbound.setasreadonly=false, but doing so is strongly discouraged. In particular EventSourced applications should not use replicateInParallel if the application is modifying inbound messages.

Compatibility Notes:

Prevention of an inbound message handler from modify is now enforced by the AepEngine, this can result in IllegalStateExceptions being thrown from an application's event handler if the application attempts to modify a received message whereas before this check was not enforced.

Prior to this release, the serialized form of the object that was removed from the store was not logged in remove entry in the transaction log (for applications using StateReplication). CDC processors typically need more information, in addition to the object's id, about the object - e.g. it's type - for it to efficiently process the remove. This story adds the object's serialized form in the remove entry in the transaction log and the deserialized form of the object in the remove event dispatched by the store to the application during initialization from the transaction log (for both primary initializing from local transaction log or backup initializing from the primary's transaction log).

This release changes handling of unchecked exceptions from a MessageFilter to use the application's AppExceptionHandlingPolicy. See AppExceptionHandlingPolicy for details.

Prior to this release, an unchecked exception from a MessageFilter was treated as an event loop error that would shut down the engine.

This release provide the ability to specify a startup role expectation of None in DDL to explicit indicate that there should be no startup expectation regarding an application's role. Prior to this release it was only possible to indicate no expectation by omitting the role expectation element in DDL making it difficult to control the expectations by environmental overrides.

Example:

This release changes the default value for usage of native time to false unless nv.time.usenative=true is explicitly set.
Compatibility Notes:

With this change it is no longer necessary to disable native time when native libraries are present.

This release changes the optimized buffer copying logic in the platform to prioritize usage of com.misc.Unsafe over using X Platform native libraries.

Testing has shown that in many cases Unsafe buffer management is lower latency than the native X runtime libraries due to JNI overhead. Consequently, Unsafe, when available has been prioritized over native buffer management. Prior to this release native buffer management had to be explicitly disabled by setting 'nv.buffermanagement.usenative=false' to use Unsafe buffer management - this is not longer required.
Compatibility Notes:

It is no longer necessary to set nv.buffermanagement.usenative=false to use Unsafe optimized buffer management.

This release changes the value of FLOW_FORWADING_MODE for the solace JNI binding to default to 1 (StoreAndForward) when not explicitly set on the solace binding descriptor. Prior to this release when not set it would be defaulted to 2 (CutThrough).
Compatibility Notes:

Applications that were setting FLOW_FORWARDING_MODE=1 in Solace JNI binding descriptors no longer need to specify it; applications that want to use CutThrough persistence must now specify FLOW_FORWARDING_MODE=2 on the binding.

In previous releases of the X Platform, special XML characters in source property files were substituted into DDL XML documents "as-is". For example, consider the following snippet from a source property file:

When we substitute nv.example.var into DDL XML using ${nv.example.var}, we might inadvertently introduce <placeholder> as a new XML tag instead of the intended "<placeholder>" literal.

As of this release, we automatically escape special XML characters in properties that originate from source property files before they are substituted into the DDL XML. In particular, <, >, &, ", ' will be respectively replaced by &lt;, &gt;, &amp;, &quot;, &apos;.

Users who prefer to do their own XML escaping can disable this new behavior by setting the following property:

Compatibility Notes:

If you have environment or property sourced values used for substitution DDL that already escape characters such as '&' with "&" You must set nv.ddl.escapesubstitutionvalues=false

This release changes packaging of the platform's native libraries into a separate artifact. This change is intended to make it operation easier for end users that require root privileges for deploy native libraries, and reduces the size of the non native artifacts.

As of this release to use the neeve native libraries the following change should be made in maven builds:

Compatibility Notes:

Users that have a dependency on the neeve native libraries must update their builds to declare the nvx-native dependency and should be aware that nvx-core-all no longer bundles the native libaries.

This release adds a new 'o2p' message latency stat that captures queuing time for outbound message sent though an engine that uses detached sends. Prior to this release the following outbound stats were captured:

• c2o: Time from message creation to when the message is offered to the binding for send
• o2s: The time from when the message was offered to the binding for send until just before serialization of the message starts.

The above statistics did not allow one to separate out the queue time in a bus binding's disruptor when operating detached. Thus to provide better visibility the additional stat 'o2p' has been added which captures the time from when the message was offered to the binding until just before the message is actually picked up for send. 'o2s' now no longer includes the time capture in 'o2p' and now reflects the time that the binding spends in its send code path prior to serialization – which is important because it covers sync (where most of serialization occurs for Xbuf encoded messsages), and also can include things like message key resolution.
Compatibility Notes:

This release adds an additional message latency stat o2p which captures the queuing time for messages send through a bus a bus manager set to do detached sends. The time captured in o2p is subtracted from o2s which used to included queuing time, but now no longer does. Tools that display message stats should be modified to inclde o2p since o2s no longer includes it.

The ADMXmlParser will now attempt to resolve imported models from the calling Thread's context classloader. The context class loader will be searched after the default classloader unless the property -Dnv.adm.contextclassloaderfirst=true is set to true.

This release disables the launch timeout for all applications launched from a talon distribution to address cases where applications may have long startup times. To revert to the old behavior of a 30 second launch timeout, specify NVSTARTUPTIMETOUT=30 in the environment prior to launch.

This change only affects applications launched from a Talon distribution using the distribution's java service wrapper.
Compatibility Notes:

Applications launched from a Talon distribution (including launches from Robin) no longer have a startup timeout enabled.

Because the nvx-talon distribution does not bundle native libraries by default it is incumbent on the user to provide native platform libraries themselves when running an application from a talon server. To facilitate automatic extraction of native libraries from application jars, the talon distribution now sets the system property 'nv.native.libdir' to indicate the native library directory to which native libs should be extracted.

This release changes store clustering configuration to be configured using the new <clustering> element under <storage> in the DDL. In prior releases clustering configuration was done via the descriptor attribute of storage ... this mechanism is now deprecated.

An example of configuring a store with a cluster element:

See DDL Clustering Configuration for a full list of supported attributes and elements.

This release fixes a deadlock that can occur during store startup:

Java stack information for the threads listed above:
===================================================
"X-STEMux-admin-1 (aff=[])":
        at com.neeve.ods.impl.nvx.NvxStoreBinding.onEvent(NvxStoreBinding.java:3662)
        - waiting to lock <0x00000002daddfe60> (a java.lang.Object)
        at com.neeve.discovery.impl.DiscoveryCacheBase.dispatchAddEvent(DiscoveryCacheBase.java:280)
        at com.neeve.discovery.impl.DiscoveryCacheBase.add(DiscoveryCacheBase.java:837)
        - locked <0x00000003205a45c0> (a com.neeve.discovery.impl.mcast.McastDiscoveryCache)
        at com.neeve.server.controller.SrvController.onAppStateChange(SrvController.java:3624)
        at com.neeve.server.controller.SrvController$AppWatcher.onAppActive(SrvController.java:660)
        at com.neeve.server.app.SrvAppLoader$AepEngineWatcher.onEngineActive(SrvAppLoader.java:1071)
        at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
        at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
        at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
        at java.lang.reflect.Method.invoke(Method.java:497)
        at com.neeve.aep.AepEventDispatcher$Handler.dispatch(AepEventDispatcher.java:146)
        at com.neeve.aep.AepEventDispatcher.dispatchToEventHandlers(AepEventDispatcher.java:322)
        at com.neeve.aep.AepEventDispatcher.dispatchToEventHandlers(AepEventDispatcher.java:359)
        at com.neeve.aep.AepEventDispatcher.onEvent(AepEventDispatcher.java:548)
        at com.neeve.aep.AepEngine.dispatchEvent(AepEngine.java:3423)
        at com.neeve.aep.AepEngine.dispatchAndDisposeEvent(AepEngine.java:3435)
        at com.neeve.aep.AepEngine.completeMessagingStartedEventProcessing(AepEngine.java:4523)
        at com.neeve.aep.AepEngine.onMessagingStarted(AepEngine.java:4640)
        - locked <0x00000003271acd88> (a com.neeve.aep.AepEngine$MessagingStartCompletionNotifier)
        at com.neeve.aep.AepEngine.onEvent(AepEngine.java:8546)
        at com.neeve.event.EventMultiplexer.dispatchEvent(EventMultiplexer.java:381)
        at com.neeve.event.EventMultiplexerSingleThreaded.dispatch(EventMultiplexerSingleThreaded.java:675)
        at com.neeve.event.EventMultiplexerSingleThreaded.access$1300(EventMultiplexerSingleThreaded.java:51)
        at com.neeve.event.EventMultiplexerSingleThreaded$CarrierEventProcessor.onEvent(EventMultiplexerSingleThreaded.java:522)
        at com.neeve.event.EventMultiplexerSingleThreaded$CarrierEventProcessor.onEvent(EventMultiplexerSingleThreaded.java:515)
        at com.lmax.disruptor.BatchEventProcessor.run(BatchEventProcessor.java:113)
        at java.lang.Thread.run(Thread.java:745)
        at com.neeve.event.EventMultiplexerSingleThreaded$ProcessorThread.run(EventMultiplexerSingleThreaded.java:280)
"X-Server-ems1-Main":
        at com.neeve.discovery.impl.DiscoveryCacheBase.matches(DiscoveryCacheBase.java:945)
        - waiting to lock <0x00000003205a45c0> (a com.neeve.discovery.impl.mcast.McastDiscoveryCache)
        at com.neeve.ods.impl.nvx.NvxStoreBinding.initMemberTable(NvxStoreBinding.java:424)
        at com.neeve.ods.impl.nvx.NvxStoreBinding.doOpen(NvxStoreBinding.java:2833)
        - locked <0x00000002daddfe60> (a java.lang.Object)
        at com.neeve.ods.impl.nvx.NvxStoreBinding.doOpen(NvxStoreBinding.java:2794)
        at com.neeve.ods.impl.StoreBindingBase.open(StoreBindingBase.java:2956)
        - locked <0x000000036126c9f8> (a java.lang.Object)
        at com.neeve.aep.AepEngine.openStore(AepEngine.java:3748)
        at com.neeve.aep.AepEngine.start(AepEngine.java:6688)
        at com.neeve.server.app.SrvAppLoader$App.start(SrvAppLoader.java:938)
        at com.neeve.server.app.SrvAppLoader.start(SrvAppLoader.java:1639)
        at com.neeve.server.app.SrvAppManager.open(SrvAppManager.java:605)
        at com.neeve.server.controller.SrvController.init(SrvController.java:4476)
        at com.neeve.daemon.controller.DmnController.start(DmnController.java:306)
        at com.neeve.daemon.DmnMain$MainThread.run(DmnMain.java:156)
        at com.neeve.daemon.DmnMain.onStart(DmnMain.java:309)
        at com.neeve.daemon.DmnMain.entryPoint(DmnMain.java:384)
        at com.neeve.server.Main.start(Main.java:54)
        at com.neeve.server.Main.main(Main.java:444)

This fix resolves a race condition in which acks for guaranteed messages filtered by the newly introduced message filtering feature can be lost.

In X v3.1, if an application is stopped concurrently by the user and the Talon XVM (server) via a command, then the XVM can experience a deadlock between the XVM thread and the application engine thread. This ticket fixes that issue.

This release fixes the following deadlock that can occur during Talon Server shutdown:

Found one Java-level deadlock:
=============================
"X-Server-s2-Main":
  waiting to lock monitor 0x00007f0178001a98 (object 0x00000000daa0e7e0, a com.neeve.lang.XLinkedHashMap),
  which is held by "X-Server-s1-Main"
"X-Server-s1-Main":
  waiting for ownable synchronizer 0x00000000dd53fef8, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
  which is held by "X-STEMux-robinTest-2"
"X-STEMux-robinTest-2":
  waiting to lock monitor 0x00007f0178001a98 (object 0x00000000daa0e7e0, a com.neeve.lang.XLinkedHashMap),
  which is held by "X-Server-s1-Main"

Java stack information for the threads listed above:
===================================================
"X-Server-s2-Main":
	at com.neeve.server.controller.SrvController$StatsRunner$Pools.onPoolAdded(SrvController.java:1442)
	- waiting to lock <0x00000000daa0e7e0> (a com.neeve.lang.XLinkedHashMap)
	at com.neeve.server.controller.SrvController$StatsRunner.onPoolAdded(SrvController.java:3230)
	at com.neeve.server.controller.SrvController.onPoolAdded(SrvController.java:3673)
	at com.neeve.server.controller.SrvController$PoolWatcher.onPoolAdded(SrvController.java:568)
	at com.neeve.util.UtlPoolRegistry.put(UtlPoolRegistry.java:131)
	at com.neeve.util.UtlPool.<init>(UtlPool.java:818)
	at com.neeve.util.UtlPool.create(UtlPool.java:849)
	at com.neeve.aep.AepEngine$Transaction.<init>(AepEngine.java:1065)
	at com.neeve.aep.AepEngine.<init>(AepEngine.java:3192)
	at com.neeve.aep.AepEngine.create(AepEngine.java:6139)
	at com.neeve.server.app.SrvAppLoader.open(SrvAppLoader.java:1564)
	at com.neeve.server.app.SrvAppManager.loadAppUnprotected(SrvAppManager.java:409)
	at com.neeve.server.app.SrvAppManager.open(SrvAppManager.java:574)
	at com.neeve.server.controller.SrvController.init(SrvController.java:4636)
	at com.neeve.daemon.controller.DmnController.start(DmnController.java:306)
	at com.neeve.robin.test.util.RobinTestServer$1.run(RobinTestServer.java:52)
	at java.lang.Thread.run(Thread.java:662)
"X-Server-s1-Main":
	at sun.misc.Unsafe.park(Native Method)
	- parking to wait for  <0x00000000dd53fef8> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
	at java.util.concurrent.locks.LockSupport.park(LockSupport.java:156)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:811)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:842)
	at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1178)
	at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:186)
	at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:262)
	at com.neeve.util.UtlPool.acquireLock(UtlPool.java:879)
	at com.neeve.util.UtlPool.size(UtlPool.java:1147)
	at com.neeve.server.controller.SrvController$StatsRunner$Pools$PoolStats.<init>(SrvController.java:1259)
	at com.neeve.server.controller.SrvController$StatsRunner$Pools.onPoolAdded(SrvController.java:1442)
	- locked <0x00000000daa0e7e0> (a com.neeve.lang.XLinkedHashMap)
	at com.neeve.server.controller.SrvController$StatsRunner.onPoolAdded(SrvController.java:3230)
	at com.neeve.server.controller.SrvController$2.apply(SrvController.java:4597)
	at cern.colt.list.ObjectArrayList.forEach(Unknown Source)
	at com.neeve.server.controller.SrvController.init(SrvController.java:4593)
	at com.neeve.daemon.controller.DmnController.start(DmnController.java:306)
	at com.neeve.robin.test.util.RobinTestServer$1.run(RobinTestServer.java:52)
	at java.lang.Thread.run(Thread.java:662)
"X-STEMux-robinTest-2":
	at com.neeve.server.controller.SrvController$StatsRunner$Pools.onPoolRemoved(SrvController.java:1451)
	- waiting to lock <0x00000000daa0e7e0> (a com.neeve.lang.XLinkedHashMap)
	at com.neeve.server.controller.SrvController$StatsRunner.onPoolRemoved(SrvController.java:3237)
	at com.neeve.server.controller.SrvController.onPoolRemoved(SrvController.java:3684)
	at com.neeve.server.controller.SrvController$PoolWatcher.onPoolRemoved(SrvController.java:576)
	at com.neeve.util.UtlPoolRegistry.remove(UtlPoolRegistry.java:215)
	at com.neeve.util.UtlPool.closeUnprotected(UtlPool.java:1053)
	at com.neeve.util.UtlPool.close(UtlPool.java:1231)
	at com.neeve.server.link.SrvLinkSmaMessageBusBinding.doClose(SrvLinkSmaMessageBusBinding.java:696)
	at com.neeve.sma.impl.MessageBusBindingBase.close(MessageBusBindingBase.java:921)
	at com.neeve.aep.AepBusManager.close(AepBusManager.java:1894)
	at com.neeve.aep.AepEngine.stopMessaging(AepEngine.java:4119)
	- locked <0x000000008d7a5c58> (a com.neeve.aep.AepEngine$MessagingStartCompletionNotifier)
	at com.neeve.aep.AepEngine.stopCore(AepEngine.java:8418)
	at com.neeve.aep.AepEngine.onEvent(AepEngine.java:8920)
	at com.neeve.event.EventMultiplexer.dispatchEvent(EventMultiplexer.java:381)
	at com.neeve.event.EventMultiplexerSingleThreaded.dispatch(EventMultiplexerSingleThreaded.java:674)
	at com.neeve.event.EventMultiplexerSingleThreaded.access$1300(EventMultiplexerSingleThreaded.java:51)
	at com.neeve.event.EventMultiplexerSingleThreaded$CarrierEventProcessor.onEvent(EventMultiplexerSingleThreaded.java:522)
	at com.neeve.event.EventMultiplexerSingleThreaded$CarrierEventProcessor.onEvent(EventMultiplexerSingleThreaded.java:515)
	at com.lmax.disruptor.BatchEventProcessor.run(BatchEventProcessor.java:113)
	at java.lang.Thread.run(Thread.java:662)
	at com.neeve.event.EventMultiplexerSingleThreaded$ProcessorThread.run(EventMultiplexerSingleThreaded.java:280)

Found 1 deadlock.

Added duplicate name check for messages. If multiple messages of same name are defined in a model, Code Generator will report error early (with line number) instead of letting it show at generated code compilation or runtime.

This release fixes a bug in ddl override handling in which the values for engine startup expectations were not being set if the ddl didn't already specify a startupExpectations (https://docs.neeveresearch.com/display/KB/DDL+Schema+Reference#DDLSchemaReference-<startupExpectations) element.
Compatibility Notes:

With this fix DDL override for startup expections will now be applied whereas before they may have been ignored.

This change adds preWireTs and postWireTs timestamps to the Solace JCSMP binding and additionally, allows capturing these values in the JNI binding even when nv.time.usenative is disabled. Prior to the latter change the timestamp in the JNI layer would not be in sync with the Java layer leading to skewed timestamps for latency calculations like w2d or s2w.

Note, however, that this comes at the cost of not measuring the time spent in the JNI portion of the binding. To measure the additional JNI binding time one must set nv.time.usenative=true and nv.time.useepochoffset=false so that JNI captured timestamps are in sync with those captured in the Java layer.

This release fixes a bug in reporting CommitTransitionLatencies in ISrvMonAppEngineStats in Server Heartbeats. Prior to this fix the accessor method was incorrectly named getCommitTransactionLatencies - this release adds a getCommitTransitionLatencies() accessor. The existing getCommitTransactionLatencies() accessor has been deprecated and will no longer be populated.
Compatibility Notes:

After upgrading to this release, processors of hearbeats should stop using getCommitTransactionLatencies() and switch to using getCommitTransitionLatencies(). Applications must upgrade to this release to correctly emit the CommitTransitionLatency statistic.

Prior to this release, there was a bug in the DDL XML parser that causes the 'enabled' flag for detached ICR send to not be parsed correctly. This release fixes this issue

This release fixes an issue with embedded entity cloning in which unset primitive fields are set on the clone as there default values. With this fix unset fields will also be unset in the clone

This release fixes a bug in which the backing SrvMonAppExceptionMessage was not being AepApplicationExceptionEvent alert when running in a Talon Server

This release fixes a race condition in discovery shutdown hook that can result in a NullPointerException or an IllegalStateException.

This release resolves a performance issue with adaptive batching and events/messages injected or scheduled in the engine. Prior to this fix it was possible that an adaptive batch would not be committed if the last event processed by the engine was a scheduled or injected event and no more events were forthcoming.

When not specified AppExceptionHandlingPolicy should default to RollbackAndStop instead of QuarantineAndStop. This release fixes this.
Compatibility Notes:

The default value for AppExceptionHandlingPolicy is now correctly set to RollbackAndStop. Applications that were relying on the default value being set to QuarantineAndStop must now explicitly set the AppExceptionHandlingPolicy.

This release resolves a bug in which some binding properties on the server side of a direct binding were being ignored

Prior to this release, there was a bug in the SrvController.stop() method that caused it to not block and wait until the server has shutdown. This release fixes this issue.

Prior to this release, the following error was intermittently reported when shutting down a server with heartbeat logging enabled:

This release fixes this issue.

This release fixes a bug which can result in heartbeats becoming corrupted when multiple admin clients (such as a Robin controller) connect to a Talon Server. This would be likely to occur if one of the clients flow controller the server sending a heartbeat. This would not affect applications that don't use Robin or other administrative tools to connect to Talon Servers.

Fixed Code generation/model XML parsing not reporting error if field or semantic type is defined under same name more than once per model.

The duplicate check can disabled at runtime by setting the system property -Dnv.adm.suppressduplicatechecks=true. This may be desirable when parsing models at runtime that had duplicates field names but were generated before the duplicate check was enforced.
Compatibility Notes:

If your application parses a model that was generated prior to enforcement of this check, the System property -Dnv.adm.suppressduplicatechecks=true must be used to suppress the parse error at runtime.

Fixes a race condition which can result in a hang during close of disruptors whose processor threads have just been started.

An example trace for such a hang would like:

Thread [main] (Suspended)    
  waiting for: EventMultiplexerSingleThreaded$ProcessorThread  (id=621) 
  Object.wait(long) line: not available [native method]       
  EventMultiplexerSingleThreaded$ProcessorThread(Thread).join(long) line: 1186 
  EventMultiplexerSingleThreaded$ProcessorThread(Thread).join() line: 1239 [local variables unavailable]       
  EventMultiplexerSingleThreaded.doClose() line: 716         
  EventMultiplexerSingleThreaded(EventMultiplexer).close() line: 555

This release fixes an issue that cause a corrupted entry in a transaction log to be included in a repaired log when repaired. This situation could occur if the corrupted entry serialized length exceeded that serialized in the entry header.

This release fixes the error 'com.google.protobuf.InvalidProtocolBufferException: Protocol message was too large. May be malicious.' when deserializing messages or entities with a serialized length > 64Mb. This fix disables a check in the protoc generated code that is intended to prevent large messages from causing an out of memory errors. This change only affects code generated by ADM with Protobuf encoding and requires code regeneration to pick up the change.
Compatibility Notes:

This is a change in the generated code for messages and entities generated with protobuf encoding. To pick up this fix, code must be regenerated.

This release fixes an issue in Talon XVM shutdown in which the default discovery cache would being opened if the XVM was configuted to use its own discovery cache. Opening the default cache can delay server shutdown while the cache is stabilized. This change fixes that.

Enabling detached pool wash can result in a deadlock. This release fixes this issue