MigratoryDataClient (com.migratorydata:client-java-api 6.0.3 API)

java.lang.Object
- com.migratorydata.client.MigratoryDataClient

```
public class MigratoryDataClient
extends Object
```
This class implements all the necessary operations for connecting to a cluster of one or more MigratoryData servers, subscribing to one or more subjects, getting real-time messages for the subscribed subjects, and publishing messages.

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`CONSTANT_WINDOW_BACKOFF` A constant used to define the reconnect policy.
`static String`	`NOTIFY_CONNECT_DENY` A constant which indicates that the client was denied to connect using the entitlement token defined on the client side.
`static String`	`NOTIFY_CONNECT_OK` A constant which indicates that the client was authorized to connect using the entitlement token defined on the client side.
`static String`	`NOTIFY_DATA_RESYNC` A constant which indicates that after a fail-over reconnection, the client successfully synchronized a subscribed subject with the latest message available for that subject, but not with the potential messages published during the fail-over, therefore behaving as a fresh client.
`static String`	`NOTIFY_DATA_SYNC` A constant which indicates that after a fail-over reconnection, the client successfully synchronized a subscribed subject with the latest message available for that subject, as well as with all messages published during the fail-over period for that subject.
`static String`	`NOTIFY_MESSAGE_SIZE_LIMIT_EXCEEDED` A constant which indicates that the client was unable to publish a message because the size of the message exceeds the message size limit allowed by the server (see the server parameter \c MAX_MESSAGE_SIZE).
`static String`	`NOTIFY_PUBLISH_DENIED` A constant which indicates that the client was not authorized to publish a message.
`static String`	`NOTIFY_PUBLISH_FAILED` A constant which indicates that the client was unable to publish a message.
`static String`	`NOTIFY_PUBLISH_OK` A constant which indicates that the client successfully published a message.
`static String`	`NOTIFY_SERVER_DOWN` A constant which indicates that the client failed to connect to a MigratoryData server.
`static String`	`NOTIFY_SERVER_UP` A constant which indicates that the client successfully connected to a MigratoryData server.
`static String`	`NOTIFY_SUBSCRIBE_ALLOW` A constant which indicates that the client was authorized to subscribe to a subject.
`static String`	`NOTIFY_SUBSCRIBE_DENY` A constant which indicates that the client was not authorized to subscribe to a subject.
`static String`	`TRANSPORT_HTTP` A constant used to define the transport type.
`static String`	`TRANSPORT_WEBSOCKET` A constant used to define the transport type.
`static String`	`TRUNCATED_EXPONENTIAL_BACKOFF` A constant used to define the reconnect policy.

Constructor Summary

Constructors
Constructor and Description

MigratoryDataClient()
Create a MigratoryDataClient object.

Constructors
Constructor and Description
`MigratoryDataClient()` Create a MigratoryDataClient object.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`advertiseInteractiveSubjects(List<String> wildcardSubjects)` Advertise interactive subjects via a list of wildcard subjects.
`void`	`connect()` Connect to the MigratoryData cluster.
`void`	`disconnect()` Disconnect from the connected MigratoryData server and dispose the resources used by the connection.
`MigratoryDataListener`	`getListener()` Get the listener for handling real-time messages and status notifications.
`Collection<String>`	`getSubjects()` \brief Return the list of subscribed subjects.
`void`	`notifyAfterFailedConnectionAttempts(int retries)` Define the number of failed attempts to connect to one or more MigratoryData servers before triggering a status notification MigratoryDataClient.NOTIFY_SERVER_DOWN.
`void`	`pause()`
`void`	`publish(MigratoryDataMessage message)` Publish a message.
`void`	`resume()`
`void`	`setBenchmarkMode(boolean b)`
`void`	`setEncryption(boolean encrypted)` Configure whether or not to use an encrypted SSL/TLS connection to communicate with the server.
`void`	`setEntitlementToken(String token)` Assign an entitlement token to the client or update its entitlement token.
`void`	`setExternalToken(String externalToken, MonotonicId monotonicId)` Assign an external token to a client.
`void`	`setHttpHeader(String header, String value)` This method allows for the inclusion of custom HTTP headers.
`void`	`setListener(MigratoryDataListener listener)` Attach a listener for handling the received real-time messages as well as the status notifications.
`void`	`setLogListener(MigratoryDataLogListener logListener, MigratoryDataLogLevel logLevel)` Attach a listener for handling log messages outputted by the library.
`void`	`setQuickReconnectInitialDelay(int seconds)` \brief Define the number of seconds to wait before attempting to reconnect to the cluster after a connection failure is detected.
`void`	`setQuickReconnectMaxRetries(int retries)` Define the maximum number of retries for the Quick Reconnect fail-over phase.
`void`	`setReconnectMaxDelay(int seconds)` Define the maximum reconnect delay for the MigratoryDataClient.TRUNCATED_EXPONENTIAL_BACKOFF policy.
`void`	`setReconnectPolicy(String policy)` Define the reconnect policy to be used after the Quick Reconnect phase.
`void`	`setReconnectTimeInterval(int seconds)` Define the time interval used for the reconnect schedule after the Quick Reconnect phase.
`void`	`setServers(String[] servers)` Specify a cluster of one or more MigratoryData servers to which the client will connect to.
`void`	`setSocketTimeoutSeconds(int seconds)`
`void`	`setSslHandshakeTimeoutSeconds(int seconds)`
`void`	`setTimestamp(boolean b)`
`void`	`setTransport(String type)` Define the transport type used by the client to communicate with the MigratoryData cluster.
`void`	`setVerboseLogEventsHandler(VerboseLogEvents logEvents)`
`void`	`subscribe(List<String> subjects)` Subscribe to one or more subjects.
`void`	`subscribeFromOffset(String subject, int epoch, int seq)`
`void`	`subscribeWithHistory(List<String> subjects, int numberOfHistoricalMessages)` Get the historical messages for one or more subjects, if any, then subscribe to those subjects.
`void`	`unsubscribe(List<String> subjects)` Unsubscribe from one or more subjects.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
 - NOTIFY_SERVER_UP
```
public static final String NOTIFY_SERVER_UP
```
 A constant which indicates that the client successfully connected to a MigratoryData server.
 
 See Also:
 
 Constant Field Values
 - NOTIFY_SERVER_DOWN
```
public static final String NOTIFY_SERVER_DOWN
```
 A constant which indicates that the client failed to connect to a MigratoryData server.
 
 See Also:
 
 Constant Field Values
 - NOTIFY_DATA_SYNC
```
public static final String NOTIFY_DATA_SYNC
```
 A constant which indicates that after a fail-over reconnection, the client successfully synchronized a subscribed subject with the latest message available for that subject, as well as with all messages published during the fail-over period for that subject.
 
 See Also:
 
 Constant Field Values
 - NOTIFY_DATA_RESYNC
```
public static final String NOTIFY_DATA_RESYNC
```
 A constant which indicates that after a fail-over reconnection, the client successfully synchronized a subscribed subject with the latest message available for that subject, but not with the potential messages published during the fail-over, therefore behaving as a fresh client.
 
 See Also:
 
 Constant Field Values
 - NOTIFY_SUBSCRIBE_ALLOW
```
public static final String NOTIFY_SUBSCRIBE_ALLOW
```
 A constant which indicates that the client was authorized to subscribe to a subject.
 
 See Also:
 
 Constant Field Values
 - NOTIFY_SUBSCRIBE_DENY
```
public static final String NOTIFY_SUBSCRIBE_DENY
```
 A constant which indicates that the client was not authorized to subscribe to a subject.
 
 See Also:
 
 Constant Field Values
 - NOTIFY_PUBLISH_OK
```
public static final String NOTIFY_PUBLISH_OK
```
 A constant which indicates that the client successfully published a message.
 
 See Also:
 
 Constant Field Values
 - NOTIFY_PUBLISH_FAILED
```
public static final String NOTIFY_PUBLISH_FAILED
```
 A constant which indicates that the client was unable to publish a message.
 
 See Also:
 
 Constant Field Values
 - NOTIFY_MESSAGE_SIZE_LIMIT_EXCEEDED
```
public static final String NOTIFY_MESSAGE_SIZE_LIMIT_EXCEEDED
```
 A constant which indicates that the client was unable to publish a message because the size of the message exceeds the message size limit allowed by the server (see the server parameter \c MAX_MESSAGE_SIZE).
 
 See Also:
 
 Constant Field Values
 - NOTIFY_PUBLISH_DENIED
```
public static final String NOTIFY_PUBLISH_DENIED
```
 A constant which indicates that the client was not authorized to publish a message.
 
 See Also:
 
 Constant Field Values
 - NOTIFY_CONNECT_OK
```
public static final String NOTIFY_CONNECT_OK
```
 A constant which indicates that the client was authorized to connect using the entitlement token defined on the client side. NOTE: This notification applies when using a Custom authorization extension built with the MigratoryData Extensions API version 2 or later. For the entitlement methods None, Basic, or Custom authorization extension built with the previous version of the MigratoryData Extensions API, this notification is always sent no matter the entitlement token is valid or not, the verification of the entitlement token being made only during subscribe and publish operations.
 
 See Also:
 
 Constant Field Values
 - NOTIFY_CONNECT_DENY
```
public static final String NOTIFY_CONNECT_DENY
```
 A constant which indicates that the client was denied to connect using the entitlement token defined on the client side. NOTE: This notification applies when using a Custom authorization extension built with the MigratoryData Extensions API version 2 or later. For the entitlement methods None, Basic, or Custom authorization extension built with the previous version of the MigratoryData Extensions API, this notification is never sent no matter the entitlement token is valid or not, the verification of the entitlement token being made only during subscribe and publish operations.
 
 See Also:
 
 Constant Field Values
 - CONSTANT_WINDOW_BACKOFF
```
public static final String CONSTANT_WINDOW_BACKOFF
```
 A constant used to define the reconnect policy. See \link MigratoryDataClient.setQuickReconnectInitialDelay() \endlink for more details about this policy.
 
 See Also:
 
 Constant Field Values
 - TRUNCATED_EXPONENTIAL_BACKOFF
```
public static final String TRUNCATED_EXPONENTIAL_BACKOFF
```
 A constant used to define the reconnect policy. See \link MigratoryDataClient.setQuickReconnectInitialDelay() \endlink for more details about this policy.
 
 See Also:
 
 Constant Field Values
 - TRANSPORT_HTTP
```
public static String TRANSPORT_HTTP
```
 A constant used to define the transport type. See \link MigratoryDataClient.setTransport() \endlink for more details about this policy.
 - TRANSPORT_WEBSOCKET
```
public static String TRANSPORT_WEBSOCKET
```
 A constant used to define the transport type. See \link MigratoryDataClient.setTransport() \endlink for more details about this policy.
- Constructor Detail
 - MigratoryDataClient
```
public MigratoryDataClient()
```
 Create a MigratoryDataClient object.
- Method Detail
 - setLogListener
```
public void setLogListener(MigratoryDataLogListener logListener,
 MigratoryDataLogLevel logLevel)
```
 Attach a listener for handling log messages outputted by the library. It is advisable to configure this listener first to log as much as possible. If no log listener is set then, by default the client will log to the console.
 
 Parameters:
 
 logListener - an implementation of the \link MigratoryDataLogListener \endlink interface
 
 logLevel - a particular \link MigratoryDataLogLevel \endlink configured as the logging threshold
 - setListener
```
public void setListener(MigratoryDataListener listener)
```
 Attach a listener for handling the received real-time messages as well as the status notifications.
 
 Parameters:
 
 listener - an implementation of the \link MigratoryDataListener \endlink interface
 - getListener
```
public MigratoryDataListener getListener()
```
 Get the listener for handling real-time messages and status notifications. This is the listener set with \link MigratoryDataClient.setListener() \endlink.
 
 Returns:
 
 the listener for handling real-time messages and status notifications
 - setServers
```
public void setServers(String[] servers)
```
 Specify a cluster of one or more MigratoryData servers to which the client will connect to. For example, to connect to a cluster formed of two MigratoryData servers installed at the addresses \c p1.example.com and \c p2.example.com, and configured to accept clients on the standard HTTP port \c 80, the following code can be used:
```
 client.setServers(new String[] {"p1.example.com:80", "p2.example.com:80"});
 
```
 To achieve load-balancing, the library connects the client to a MigratoryData server chosen randomly from the \c servers list. In this way, the load is balanced among all the members of the cluster.
 Moreover, the library supports weighted load-balancing. This feature is especially useful if the MigratoryData servers in the cluster are installed on machines with different capacities. You can assign to each member of the cluster a \em weight ranging from \c 0 to \c 100. This weight assignment is a hint provided to the library to select with a higher probability a MigratoryData server with a higher weight either initially when the client connects to the cluster or later during a fail-over reconnection. Supposing the address \c p1.example.com corresponds to a machine that is twice more powerful than the machine having the address \c p2.example.com, then you can assign to \c p1.example.com a weight \c 100 and to \c p2.example.com a weight \c 50 by prefixing each address with the assigned weight as follows:
 client.setServers(new String[] {"100 p1.example.com:80", "50 p2.example.com:80"});
 The library assigns a default weight \c 100 to the addresses not prefixed with a specific weight. 
 To achieve failover, if the connection between the client and a MigratoryData server is broken, then the library will automatically detect the failure and will select another MigratoryData server from the \c servers list. If the client fails to connect to the newly selected server, a status notification MigratoryDataClient.NOTIFY_SERVER_DOWN will be triggered (unless you modify the number of failed connection attempts with \link MigratoryDataClient.notifyAfterFailedConnectionAttempts() \endlink), and a new MigratoryData server of the cluster will be selected again and again until the client will be able to connect to one of the MigratoryData servers of the cluster. When successfully connected the library will trigger a status notification MigratoryDataClient.NOTIFY_SERVER_UP.
 Parameters:
 
 servers - an array of strings where each string represents the network address (IP address or DNS domain name and its corresponding port) of a MigratoryData server, optionally prefixed by a weight ranging from \c 0 to \c 100; if the weight prefix is not provided to an address, then the \c 100 weight will be automatically assigned to that address
 - connect
```
public void connect()
```
 Connect to the MigratoryData cluster. Use this method to connect to one of the MigratoryData servers specified with \link MigratoryDataClient.setServers() \endlink.
 - subscribe
```
public void subscribe(List<String> subjects)
```
 Subscribe to one or more subjects. As an example, supposing messages are market data updates having as subjects stock names. Then, to subscribe for the messages having as subjects \c /stocks/NYSE/IBM and \c /stocks/Nasdaq/MSFT use:
```
 List<String> subjects = new ArrayList<String>();
 subjects.add("/stocks/NYSE/IBM");
 subjects.add("/stocks/Nasdaq/MSFT");
 client.subscribe(subjects);
 
```
 The subjects are strings having a particular syntax. See the "Concepts" section of the Architecture Guide to learn the syntax of the subjects.
 Parameters:
 
 subjects - subjects to subscribe
 - subscribeWithHistory
```
public void subscribeWithHistory(List<String> subjects,
 int numberOfHistoricalMessages)
```
 Get the historical messages for one or more subjects, if any, then subscribe to those subjects. Attempt to get the number of historical messages as defined by the argument \c numberOfHistoricalMessages, for each subject in the argument \c subjects, then subscribe to than subject. When Guaranteed Message Delivery is enabled, each MigratoryData server of the cluster maintains an in-memory cache with historical messages for each subject. The cache of each subject is available in all servers of the cluster. The maximum number of messages held in cache is defined by the parameter \c MaxCachedMessagesPerSubject of the MigratoryData server which defaults to 1,000 messages. The historical messages are continuously removed from the cache, but it is guaranteed that they are available in the cache at least the number of seconds defined by the parameter \c CacheExpireTime which defaults to \c 180 seconds. Note: If the value of \c numberOfHistoricalMessages is higher than the number of historical messages available in the cache, then the client will receive only the messages available in the cache. As a consequence, if you use a value higher than the value of the value of the parameter \c MaxCachedMessagesPerSubject of the MigratoryData server (which defaults to 1000), then you will get the entire cache before subscribing to the subjects specified with this API method. If the value of \c numberOfHistoricalMessages is \c 0, then this API method is equivalent to the API method \link MigratoryDataClient.subscribe() \endlink. 
 
 Parameters:
 
 subjects - subjects to subscribe
 
 numberOfHistoricalMessages - the number of historical messages to be retrieved from the cache of the server
 - subscribeFromOffset
```
public void subscribeFromOffset(String subject,
 int epoch,
 int seq)
```
 - unsubscribe
```
public void unsubscribe(List<String> subjects)
```
 Unsubscribe from one or more subjects.
 
 Parameters:
 
 subjects - subjects to unsubscribe
 - setEncryption
```
public void setEncryption(boolean encrypted)
```
 Configure whether or not to use an encrypted SSL/TLS connection to communicate with the server. When using encryption you should connect to the ports of the MigratoryData server that are configured with the parameter \c ListenEncrypted to listen for encrypted connections.
 
 Parameters:
 
 encrypted - indicate whether or not to use an encrypted SSL/TLS connection to communicate with the server
 - setEntitlementToken
```
public void setEntitlementToken(String token)
```
 Assign an entitlement token to the client or update its entitlement token. To define which users of your application are entitled to subscribe to which subjects and/or to publish messages for which subjects, you will first have to configure an entitlement method using the parameter \c Entitlement of the MigratoryData server. Please refer to the documentation of the \c Entitlement parameter in the Configuration Guide to learn how to configure an entitlement method.
 
 Parameters:
 
 token - an entitlement token.
 - getSubjects
```
public Collection<String> getSubjects()
```
 \brief Return the list of subscribed subjects.
 
 Returns:
 
 the subscribed subjects
 - notifyAfterFailedConnectionAttempts
```
public void notifyAfterFailedConnectionAttempts(int retries)
```
 Define the number of failed attempts to connect to one or more MigratoryData servers before triggering a status notification MigratoryDataClient.NOTIFY_SERVER_DOWN.
 
 Parameters:
 
 retries - the number of the failed attempts to connect to one or more MigratoryData servers before triggering a status notification MigratoryDataClient.NOTIFY_SERVER_DOWN; the default is \c 1
 - disconnect
```
public void disconnect()
```
 Disconnect from the connected MigratoryData server and dispose the resources used by the connection. This method should be called when the connection is no longer necessary.
 - publish
```
public void publish(MigratoryDataMessage message)
```
 Publish a message. If the message includes a closure, then a status notification will be provided via \link MigratoryDataListener.onStatus() \endlink to inform whether the message publication has been successful or not.
 
 Parameters:
 
 message - a MigratoryDataMessage message
 - setQuickReconnectMaxRetries
```
public void setQuickReconnectMaxRetries(int retries)
```
 Define the maximum number of retries for the Quick Reconnect fail-over phase. See \link MigratoryDataClient.setQuickReconnectInitialDelay() \endlink to learn about the Quick Reconnect phase.
 
 Parameters:
 
 retries - the maximum number of quick reconnect retries; the default is \c 3
 - setQuickReconnectInitialDelay
```
public void setQuickReconnectInitialDelay(int seconds)
```
 \brief Define the number of seconds to wait before attempting to reconnect to the cluster after a connection failure is detected. Reconnection Phases and Policies When a connection failure is detected, the API will attempt to reconnect to the servers of the MigratoryData cluster as follows: First, it will attempt to reconnect up to a number of times as defined by \link MigratoryDataClient.setQuickReconnectMaxRetries() \endlink using small delays between retries ("Quick Reconnection Phase"). If the connection cannot be established after the Quick Reconnection Phase, then the API will attempt to reconnect less frequently according to the policy defined by \link MigratoryDataClient.setReconnectPolicy() \endlink. The delays between retries are computed according to the following algorithm where the values of the variables involved are defined by the API methods having substantially the same names:
```
 Quick Reconnect Phase (retries <= quickReconnectMaxRetries)
 -----------------------------------------------------------
 
 (retries starts with 1 and increment by 1 at each quick reconnect)
 
 reconnectDelay = quickReconnectInitialDelay * retries - random(0, quickReconnectInitialDelay)
 
 After Quick Reconnect Phase (retries > quickReconnectMaxRetries)
 ----------------------------------------------------------------
 
 (reset retries to start with 1 and increment by 1 at each reconnect)
 
 If reconnectPolicy is CONSTANT_WINDOW_BACKOFF, then 
 
 reconnectDelay = reconnectTimeInterval
 
 else if reconnectPolicy is TRUNCATED_EXPONENTIAL_BACKOFF, then
 
 reconnectDelay = min(reconnectTimeInterval * (2 ^ retries) - random(0, reconnectTimeInterval * retries), reconnectMaxDelay)
 
```
 For a few users which are subject to temporary, atypical network conditions, if reconnectDelay computed with the algorithm above is less than 10 seconds, then it is rounded to 10 seconds.
 Parameters:
 
 seconds - the number of seconds to wait before attempting to reconnect to the cluster; the default is \c 5
 - setReconnectPolicy
```
public void setReconnectPolicy(String policy)
```
 Define the reconnect policy to be used after the Quick Reconnect phase. See \link MigratoryDataClient.setQuickReconnectInitialDelay() \endlink to learn about the Quick Reconnect phase and the reconnect schedule for the policy defined by this method.
 
 Parameters:
 
 policy - the reconnect policy to be used after the Quick Reconnect phase; the possible values are: \link MigratoryDataClient.CONSTANT_WINDOW_BACKOFF \endlink and \link MigratoryDataClient.TRUNCATED_EXPONENTIAL_BACKOFF \endlink; the default is the last one
 - setReconnectTimeInterval
```
public void setReconnectTimeInterval(int seconds)
```
 Define the time interval used for the reconnect schedule after the Quick Reconnect phase. See \link MigratoryDataClient.setQuickReconnectInitialDelay() \endlink to learn about the Quick Reconnect phase and the reconnect schedule for the policy defined by this method.
 
 Parameters:
 
 seconds - a time interval expressed in seconds used for reconnect schedule; the default is \c 20
 - setReconnectMaxDelay
```
public void setReconnectMaxDelay(int seconds)
```
 Define the maximum reconnect delay for the MigratoryDataClient.TRUNCATED_EXPONENTIAL_BACKOFF policy. See \link MigratoryDataClient.setQuickReconnectInitialDelay() \endlink to learn how the value defined by this method is used.
 
 Parameters:
 
 seconds - the maximum reconnect delay when using the MigratoryDataClient.TRUNCATED_EXPONENTIAL_BACKOFF policy; the default value is \c 360 seconds
 - setExternalToken
```
public void setExternalToken(String externalToken,
 MonotonicId monotonicId)
```
 Assign an external token to a client. An external token assigned to a client can be typically used by a plugin of the MigratoryData server implemented with the Presence API to enable the communication of that client with an external service. For example, the MigratoryData plugin for Firebase needs an FCM token in order to be able to push notifications via the Firebase service to a mobile client. The mobile client can provide the FCM token to the plugin using this method. To be able to order the online and offline events in the presence plugin, each connection of a client having an external token should be accompanied by a monotonic id. A monotonic id is simply a unique id having at each connection a value higher than the value of the previous connection. For Android applications you can use com.migratorydata.client.utils.SharedPreferencesMonotonicId which is a class which provides a monotonic id implementation. The monotonic id is stored in the SharedPreferences such that it can tolerate application failures or Android device restarts.
 
 Parameters:
 
 externalToken - a token
 
 monotonicId - an implementation of the MonotonicId interface
 - setTransport
```
public void setTransport(String type)
```
 Define the transport type used by the client to communicate with the MigratoryData cluster.
 
 Parameters:
 
 type - the possible values are: MigratoryDataClient.TRANSPORT_HTTP and MigratoryDataClient.TRANSPORT_WEBSOCKET; the default value is the last one
 - advertiseInteractiveSubjects
```
public void advertiseInteractiveSubjects(List<String> wildcardSubjects)
```
 Advertise interactive subjects via a list of wildcard subjects.
 
 If the Interactive Publishing extension is enabled in the MigratoryData server, i.e. the parameter Extension.InteractivePublishing of the MigratoryData server is set on true, then you can use this API method to advertise the subjects to be used for interactive publishing as detailed below.
 
 First, a wildcard subject is a MigratoryData subject where the last segment is *. For example, by using the wildcard subject /stocks/ibm/* in the argument of this API method, it will advertise the interactive subjects that start with /stocks/ibm/, e.g. /stocks/ibm/last/bid, /stocks/ibm/level2/price etc. We say that an interactive subject, say /stocks/ibm/last/bid, matches the wildcard subject /stocks/ibm/*.
 
 Warning: Currently only wildcard subjects with two segments are supported. For example, the following wildcard subject with two segments /stocks/* is supported. However, the following wildcard subject /quotes/nyse/* is not currently supported as it has three segments. You need to use the broader wildcard subject /quotes/* to advertise interactive subjects matching /quotes/nyse/*. To learn more about the valid syntax of subjects, please check out the Concepts section of the product documentation.
 
 An interactive subject is a subject for which this API triggers subscription events such as the first subscribe event and the last unsubscribe event. These events are triggered via the callbacks MigratoryDataInteractiveListener.onSubscribe(String) and MigratoryDataInteractiveListener.onUnsubscribe(String) of the interface MigratoryDataInteractiveListener.
 
 The interactive subjects and theirs subscription events are useful to implement interactive publishers, i.e. publishers that can start publishing data messages on an interactive subject when a client subscribes for the first time to that interactive subject, and stop publishing data messages when there are no more clients subscribed to that interactive subject.
 
 Parameters:
 
 wildcardSubjects - A list of wildcard subjects.
 - setHttpHeader
```
public void setHttpHeader(String header,
 String value)
```
 This method allows for the inclusion of custom HTTP headers. In the case of the WebSocket transport, the added headers are transmitted during the handshake. For the HTTP transport, the added headers are sent with every client request. This functionality is particularly useful when an authentication solution is in place between the client and the MigratoryData server, which requires an HTTP header containing an authentication token.
 
 Parameters:
 
 header - header name
 
 value - header value
 - setTimestamp
```
public void setTimestamp(boolean b)
```
 - setBenchmarkMode
```
public void setBenchmarkMode(boolean b)
```
 - pause
```
public void pause()
```
 - resume
```
public void resume()
```
 - setVerboseLogEventsHandler
```
public void setVerboseLogEventsHandler(VerboseLogEvents logEvents)
```
 - setSocketTimeoutSeconds
```
public void setSocketTimeoutSeconds(int seconds)
```
 - setSslHandshakeTimeoutSeconds
```
public void setSslHandshakeTimeoutSeconds(int seconds)
```

Class MigratoryDataClient

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

NOTIFY_SERVER_UP

NOTIFY_SERVER_DOWN

NOTIFY_DATA_SYNC

NOTIFY_DATA_RESYNC

NOTIFY_SUBSCRIBE_ALLOW

NOTIFY_SUBSCRIBE_DENY

NOTIFY_PUBLISH_OK

NOTIFY_PUBLISH_FAILED

NOTIFY_MESSAGE_SIZE_LIMIT_EXCEEDED

NOTIFY_PUBLISH_DENIED

NOTIFY_CONNECT_OK

NOTIFY_CONNECT_DENY

CONSTANT_WINDOW_BACKOFF

TRUNCATED_EXPONENTIAL_BACKOFF

TRANSPORT_HTTP

TRANSPORT_WEBSOCKET

Constructor Detail

MigratoryDataClient

Method Detail

setLogListener

setListener

getListener

setServers

connect

subscribe

subscribeWithHistory

subscribeFromOffset

unsubscribe

setEncryption

setEntitlementToken

getSubjects

notifyAfterFailedConnectionAttempts

disconnect

publish

setQuickReconnectMaxRetries

setQuickReconnectInitialDelay

setReconnectPolicy

setReconnectTimeInterval

setReconnectMaxDelay

setExternalToken

setTransport

advertiseInteractiveSubjects

setHttpHeader

setTimestamp

setBenchmarkMode

pause

resume

setVerboseLogEventsHandler

setSocketTimeoutSeconds

setSslHandshakeTimeoutSeconds