Package com.lightstreamer.interfaces.data

Interface DataProvider

All Known Subinterfaces:
SmartDataProvider
public interface DataProvider
Provides an interface to be implemented by a Data Adapter in order to attach a Data Provider to Lightstreamer Kernel. The configuration of an Adapter instance requires the following items:
  • a unique identification for the instance;
  • the Adapter class name;
  • optional configuration parameters.
This is accomplished through the "adapters.xml" configuration files.
A single instance of each configured Adapter is created by Lightstreamer Kernel at startup. For this purpose, any Data Adapter must provide a void constructor. After creation, the init method is called, providing the Data Adapter with the configuration information; then, the Kernel sets itself as the Data Adapter listener, by calling the setListener method.
Data Providers are used by Lightstreamer Kernel to obtain all data to be pushed to the Clients. Any Item requested by a Client must refer to one supplied by the configured Data Adapters.
A Data Provider supplies data in a publish/subscribe way. Lightstreamer Kernel asks for data by calling the subscribe and unsubscribe methods for various Items and the Data Adapter sends ItemEvents to its listener in an asynchronous way.
A Data Adapter can also support Snapshot management. Upon subscription to an item, the current state of the Item data can be sent to the Kernel before the updates. This allows the Kernel to maintain the Item state, by integrating the new ItemEvents into the state (in a way that depends on the Item mode) and to make this state available to the Clients.
Note that the interaction between the Kernel and the Data Adapter and the interaction between the Kernel and any Client are independent activities. As a consequence, the very first ItemEvents sent by the Data Adapter to the Kernel for an Item just subscribed to might be processed before the Kernel starts feeding any client, even the client that caused the subscription to the Item to be invoked; then, such events would not be forwarded to any client. If it is desirable that a client receives all the ItemEvents that have been produced for an Item by the Data Adapter since subscription time, then the support for the Item Snapshot can be leveraged.
Lightstreamer Kernel ensures that calls to subscribe and unsubscribe for the same Item will be interleaved, without redundant calls; whenever subscribe throws an exception, the corresponding unsubscribe call is not issued.

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final String
    ADD_COMMAND
    Constant that can be used as the "ADD" value for the "command" fields of Items to be processed in COMMAND mode.
    static final String
    COMMAND_FIELD
    Constant that can be used as field name for the "command" field in Items to be processed in COMMAND mode.
    static final String
    DELETE_COMMAND
    Constant that can be used as the "DELETE" value for the "command" fields of Items to be processed in COMMAND mode.
    static final String
    KEY_FIELD
    Constant that can be used as field name for the "key" field in Items to be processed in COMMAND mode.
    static final String
    UPDATE_COMMAND
    Constant that can be used as the "UPDATE" value for the "command" fields of Items to be processed in COMMAND mode.

  • Method Summary

    Modifier and Type
    Method
    Description
    void
    init(Map params, File configDir)
    Called by Lightstreamer Kernel to provide initialization information to the Data Adapter.
    boolean
    isSnapshotAvailable(String itemName)
    Called by Lightstreamer Kernel to know whether the Data Adapter, after a subscription for an Item, will send some Snapshot ItemEvents before sending the updates.
    void
    setListener(ItemEventListener listener)
    Called by Lightstreamer Kernel to provide a listener to receive the ItemEvents carrying data and asynchronous error notifications.
    void
    subscribe(String itemName, boolean needsIterator)
    Called by Lightstreamer Kernel to request data for an Item.
    void
    unsubscribe(String itemName)
    Called by Lightstreamer Kernel to end a previous request of data for an Item.

  • Field Details

    • KEY_FIELD

      @Nonnull static final String KEY_FIELD
      Constant that can be used as field name for the "key" field in Items to be processed in COMMAND mode.
      See Also:

    • COMMAND_FIELD

      @Nonnull static final String COMMAND_FIELD
      Constant that can be used as field name for the "command" field in Items to be processed in COMMAND mode.
      See Also:

    • ADD_COMMAND

      @Nonnull static final String ADD_COMMAND
      Constant that can be used as the "ADD" value for the "command" fields of Items to be processed in COMMAND mode.
      See Also:

    • UPDATE_COMMAND

      @Nonnull static final String UPDATE_COMMAND
      Constant that can be used as the "UPDATE" value for the "command" fields of Items to be processed in COMMAND mode.
      See Also:

    • DELETE_COMMAND

      @Nonnull static final String DELETE_COMMAND
      Constant that can be used as the "DELETE" value for the "command" fields of Items to be processed in COMMAND mode.
      See Also:

  • Method Details

    • init

      void init(@Nonnull Map params, @Nonnull File configDir) throws DataProviderException
      Called by Lightstreamer Kernel to provide initialization information to the Data Adapter. The call must not be blocking; any polling cycle or similar must be started in a different thread. Any delay in returning from this call will in turn delay the Kernel initialization. If an exception occurs in this method, Lightstreamer Kernel can't complete the startup and must exit.
      Parameters:
      params - A Map-type value object that contains name-value pairs corresponding to the "param" elements supplied in the Data Adapter configuration file under the "data_provider" element. Both names and values are represented as String objects.
      In addition, the following entries are added by the Server:
      • "adapters_conf.id" - the associated value is a string which reports the name configured for the Adapter Set, i.e. the name specified for the "id" attribute of the <adapters_conf> element;
      • "data_adapter.name" - the associated value is a string which reports the name configured for the Data Adapter, i.e. the name specified for the "name" attribute of the <data_providerf> element (or its default, which is "default").
      configDir - The path of the directory on the local disk where the Data Adapter configuration file resides.
      Throws:
      DataProviderException - if an error occurs that prevents the correct behavior of the Data Adapter. This causes the Server not to complete the startup and to exit.

    • setListener

      void setListener(@Nonnull ItemEventListener listener)
      Called by Lightstreamer Kernel to provide a listener to receive the ItemEvents carrying data and asynchronous error notifications. The listener is set before any subscribe is called and is never changed.
      Parameters:
      listener - a listener.

    • subscribe

      void subscribe(@Nonnull String itemName, boolean needsIterator) throws SubscriptionException, FailureException
      Called by Lightstreamer Kernel to request data for an Item. If the request succeeds, the Data Adapter can start sending an ItemEvent to the listener for any update of the Item value. Before sending the updates, the Data Adapter may optionally send one or more ItemEvents to supply the current Snapshot.
      The general rule to be followed for event dispatching is: 
            if isSnapshotAvailable(itemName) == true
           SNAP* [EOS] UPD*
      else
           UPD*
      where:
      • SNAP represents an update call with the isSnapshot flag set to true
      • EOS represents an endOfSnapshot call
      • UPD represents an update call with the isSnapshot flag set to false; in this case, the special clearSnapshot call can also be issued.
      The composition of the snapshot depends on the Mode in which the item is to be processed. In particular, for MERGE mode, the snapshot consists of one event and the first part of the rule becomes: 
                 [SNAP] [EOS] UPD*
      where a missing snapshot is considered as an empty snapshot.
      If an item can be requested only in RAW mode, then isSnapshotAvailable should always return false; anyway, when an item is requested in RAW mode, any snapshot is discarded.
      Note that calling endOfSnapshot is not mandatory; however, not calling it in DISTINCT or COMMAND mode may cause the server to keep the snapshot and forward it to the clients only after the first non-shapshot event has been received. The same happens for MERGE mode if neither the snapshot nor the endOfSnapshot call are supplied.
      Unexpected snapshot events are converted to non-snapshot events (but for RAW mode, where they are ignored); unexpected endOfSnapshot calls are ignored.

      The method should perform as fast as possible. If the implementation is slow because of complex subscription activation operations, it might delay a subsequent unsubscription and resubscription of the same item. In that case, configuring a dedicated "DATA" thread pool for this Data Adapter is recommended, in order not to block operations for different Data Adapters.
      Parameters:
      itemName - Name of an Item.
      needsIterator - Signals that the getNames method will be called on the ItemEvents received for this Item. If this flag is set to false, the ItemEvent objects sent for this Item need not implement the method.
      Throws:
      SubscriptionException - if the request cannot be satisfied. A failed subscription is not notified to the clients; it just causes the clients not to receive data. Upon a failed subscription, the related unsubscribe(String) call will not be issued.
      FailureException - if the method execution has caused a severe problem that can compromise future operation of the Data Adapter. This causes the whole Server to exit, so that an external recovery mechanism may come into action.
      See Also:

    • unsubscribe

      void unsubscribe(@Nonnull String itemName) throws SubscriptionException, FailureException
      Called by Lightstreamer Kernel to end a previous request of data for an Item. After the call has returned, no more ItemEvents for the item should be sent to the listener until requested by a new subscription for the same item.

      The method should perform fast. If the implementation is slow because of complex housekeeping operations, it might delay a subsequent subscription of the same item. In that case, configuring a dedicated "DATA" thread pool for this Data Adapter is recommended, in order not to block operations for different Data Adapters.
      Parameters:
      itemName - Name of an Item.
      Throws:
      SubscriptionException - if the request cannot be satisfied. This does not prevent Lightstreamer Kernel from calling unsubscribe(String) again for the same item, if needed.
      FailureException - if the method execution has caused a severe problem that can compromise future operation of the Data Adapter. This causes the whole Server to exit, so that an external recovery mechanism may come into action.

    • isSnapshotAvailable

      boolean isSnapshotAvailable(@Nonnull String itemName) throws SubscriptionException
      Called by Lightstreamer Kernel to know whether the Data Adapter, after a subscription for an Item, will send some Snapshot ItemEvents before sending the updates. An item Snapshot can be represented by zero, one or more ItemEvents, also depending on the item mode. The decision whether to supply or not to supply Snapshot information is entirely up to the Data Adapter.

      The method should perform fast. The availability of the snapshot for an item should be a known architectural property. If the snapshot is expected, but then cannot be obtained at subscription time, then it can only be considered as empty. If the implementation is slow, it will delay the subscription. In that case, configuring a dedicated "DATA" thread pool for this Data Adapter is recommended, in order not to block operations for different Data Adapters.
      Parameters:
      itemName - Name of an Item.
      Returns:
      true if Snapshot information will be sent for this Item before before the updates.
      Throws:
      SubscriptionException - if the Data Adapter is unable to answer to the request. This causes the subscription to fail and the proper subscribe(String, boolean) call not to be issued. A failed subscription is not notified to the clients; it just causes the clients not to receive data.