Request-Response APIs

**Mone** · February 21st, 2007, 02:04 PM

Originally Posted by Mone

1#
- subscribe to specific items (e.g. profiles, portfolios) [= Request]
- receive the data snapshot [= Response]
- unsubscribe to that item after the snapshot has been received
The Data Adapter will have to retrieve the right data according to the item names (or more precisely
group names).

I want to expand on this topic through a simple example.
We will see a DataAdapter that responds to our requests with a list of 5 elements. Each element of the list has 2 fields, "key" that contains the name of the subscribed item plus a progressive and value that contains the string "Value" plus the same progressive.

First of all we compose the adapters.xml file for the adapter. We will use the LiteralBasedProvider as MetaDataProvider and our custom class FakeSubAdapter as DataProvider.
Moreover we configure the LiterBasedProvider with some parameters:

distinct_snapshot_length - is the maximum number of snapshot events available for each item of the adapter. This is the value returned by the getDistinctSnapshotLength method; implementing your own MetaDataProvider this value could be different per each item.
item_family_1 - is used as a Pattern to group items inside a family. Using .* we group in the same family all possible items.
modes_for_item_family_1 - lists the admitted subscription modes for items pertaining to item_family_1. We admit only DISTINCT subscriptions.

This is the adapters.xml file

Code xml:

<?xml version="1.0"?>
 
<adapters_conf id="FAKESUB">
    <metadata_provider>
        <adapter_class>com.lightstreamer.adapters.metadata.LiteralBasedProvider</adapter_class>
        <param name="distinct_snapshot_length">5</param>
        <param name="item_family_1">.*</param>
        <param name="modes_for_item_family_1">DISTINCT</param>
    </metadata_provider>
 
    <data_provider>
        <adapter_class>com.lightstreamer.req_resp_examples.fake_sub.FakeSubAdapter</adapter_class>
    </data_provider>
</adapters_conf>

This is the DataProvider implementation (refer to comments inside the code for the explanations on how it works):

Code java:

package com.lightstreamer.req_resp_examples.fake_sub;
 
import java.io.File;
import java.util.HashMap;
import java.util.Map;
 
import com.lightstreamer.interfaces.data.DataProvider;
import com.lightstreamer.interfaces.data.DataProviderException;
import com.lightstreamer.interfaces.data.FailureException;
import com.lightstreamer.interfaces.data.ItemEventListener;
import com.lightstreamer.interfaces.data.SubscriptionException;
 
public class FakeSubAdapter implements DataProvider {
 
    private HashMap responseThreads = new HashMap();
    private ItemEventListener listener;
    
    public void init(Map params, File configDir) throws DataProviderException {
        return;
    }
 
    public void setListener(ItemEventListener listener) {
        //set the listener that will receive the updates
        this.listener = listener;
    }
 
    public void subscribe(String itemName, boolean needsIterator) throws SubscriptionException, FailureException {
        //create the thread that will handle the response. In a production
        //scenario you would probably use a pool, but for this example 
        //create a new thread per each subscription is enough
        ResponseThread rt = new ResponseThread(itemName);
        //take trace of each subscribtion-related thread
        responseThreads.put(itemName,rt);
        //starts the thread that will send the response to clients
        rt.start();
    }
 
    public void unsubscribe(String itemName) throws SubscriptionException, FailureException {
        ResponseThread rt = (ResponseThread) responseThreads.get(itemName);
        if (rt != null) {
            //remove from subscription-related threads list
            responseThreads.remove(itemName);
            //if the thread is sending something (ie it has not finished to send the snapshot
            //that is our response) we stop it
            rt.end();
        }
    }
 
    public boolean isSnapshotAvailable(String itemName) throws SubscriptionException {
        //in this case we send ONLY the snapshot, so it is obviously always available
        return true;
    }
 
    public class ResponseThread extends Thread {
        
        private String itemName;
        private volatile boolean exit = false;
    
        
        public ResponseThread(String itemName) {
            //save the itemName, we will use this name as part of the
            //updates
            this.itemName = itemName;
        }
 
        public void run() {
            //the response will be a DISTINCT table with 5 rows
            for(int i=1; i<=5 && !this.exit; i++) {
                //compose a Map to be passed to Lightstreamer kernel
                HashMap row = new HashMap(); 
                row.put("key",this.itemName + "->" +String.valueOf(i));
                row.put("value","Value"+i);
                //pass the map to Lightstreamer kernel. This is an update.
                if (!this.exit)listener.update(this.itemName,row,true);
            }
            //send the endOfSnapshot signal (ie response is finished)
            if (!this.exit)listener.endOfSnapshot(this.itemName);
        }
        
        public void end() {
            //set a flag to stop updates
            this.exit = true;
        }
        
    }
    
}