Guideline for ExceptionHandler

tvhnet2013

Hi,

You menitioned in "\DOCS-SDKs\sdk_adapter_dotnet\examples\Remote_StockListDemo_Adapters\Deployment\Deployment_LS(robust)\StockList_sockets\adapters.xml":

+ RobustNetworkedMetadataProvider: "Moreover, this Metadata Adapter manages the case in which the remote counterpart is missing, by just refusing all new requests from the clients and storing all state change notifications that have to be sent to the backend (namely, session closing and table closing notifications). Meanwhile, this Metadata Adapter keeps waiting for a connection from a new remote server; upon connection, it will flush pending notifications, then start working normally."

+ RobustNetworkedDataProvider: "This Data Adapter also manages failures of the remote counterpart, by waiting for connection from a new remote server and trying to recover the data flow."

I don't know how Remote .NET Adapter Server, Remote .NET Metadata Adapter, and Remote .NET Data Adapter work together with those "robust" proxies in case of failure? What is proper way to implement Server's ExceptionHandler to recover failure?

I read in "DOCS-SDKs\sdk_adapter_dotnet\examples\Remote_Portfolio_Adapters\src_standalone_launcher\StandaloneAdaptersLauncher.cs", you noted that:

        // Notes about exception handling.        
        // 
        // In case of exception, the whole Remote Server process instance
        // can no longer be used;
        // closing it also ensures that the Proxy Adapter closes
        // (thus causing Lightstreamer Server to close)
        // or recovers by accepting connections from a new Remote
        // Server process instance.
        // 
        // Keeping the process instance alive and replacing the Server
        // class instances would be possible.
        // This would issue new connections with Lightstreamer Server.
        // However, new instances of the Remote Adapters would also be needed
        // and a cleanup of the current instances should be performed,
        // by invoking them directly through a custom method.

It is very good if you can provide completed example for failure recovery at remote server side.

Thanks.

Giuseppe Corti

Hi tvhnet2013,

I attach below the example of a demo Adapters launcher (modified from the StandaloneAdaptersLauncher.cs) to handle cases of failure without exiting.
[SYNTAX=CSHARP]namespace Lightstreamer.Adapters.MyDemo
{
public class AdaptersLauncher
{
private static ILog _log = LogManager.GetLogger("Lightstreamer.Adapters.MyDemo.AdaptersLauncher");

public const string PREFIX1 = "-";
public const string PREFIX2 = "/";

public const char SEP = '=';

public const string ARG_HELP_LONG = "help";
public const string ARG_HELP_SHORT = "?";

public const string ARG_HOST = "host";
public const string ARG_METADATA_RR_PORT = "metadata_rrport";
public const string ARG_DATA_RR_PORT = "data_rrport";
public const string ARG_DATA_NOTIF_PORT = "data_notifport";
public const string ARG_NAME = "name";

private static string host = null;
private static int rrPortMD = -1;
private static int rrPortD = -1;
private static int notifPortD = -1;
private static string name = null;
private static IDictionary parameters = null;
private static PortfolioFeedSimulator feed = null;

public static bool LaunchDataProviderServer(DataProviderServer oldInstance)
{
DataProviderServer server = new DataProviderServer();
Lightstreamer.Adapters.MyDemo.Data.MyDemoAdapter my_adapter =
new Lightstreamer.Adapters.MyDemo.Data.MyDemoAdapter();

my_adapter.SetFeed(feed);

server.Adapter = my_adapter;

if (name != null) server.Name = name;
_log.Debug("Remote Data Adapter initialized");

if (oldInstance != null)
{
my_adapter.RecoveryState((Data.MyAdapter)oldInstance.Adapter);
((Data.MyAdapter)(oldInstance.Adapter)).CleanUp();
}

ServerStarter starter = new ServerStarter(host, rrPortD, notifPortD);
starter.Launch(server);

return true;
}

public static bool LaunchMetaDataProviderServer(MetadataProviderServer oldInstance)
{
MetadataProviderServer server = new MetadataProviderServer();
Lightstreamer.Adapters.MyDemo.Metadata.MyMetadataAdapter my_adapter =
new Lightstreamer.Adapters.MyDemo.Metadata.MyMetadataAdapter();

my_adapter.SetFeed(feed);

server.Adapter = my_adapter;
server.AdapterParams = parameters;

if (name != null) server.Name = name;
_log.Debug("Remote Metadata Adapter initialized");

if (oldInstance != null)
{
my_adapter.RecoveryState((Metadata.PortfolioMetadataAdapter)oldInstance.Adapter);
((Metadata.PortfolioMetadataAdapter)(oldInstance.Adapter)).CleanUp();
}

ServerStarter starter = new ServerStarter(host, rrPortMD, -1);
starter.Launch(server);

return true;
}

public static void Main(string[] args)
{
if (args.Length == 0) Help();

_log.Info("My Demo .NET Adapter Custom Server starting...");

parameters = new Hashtable();

// Read parameter from command line

feed = new MyFeedSimulator();
// A reference to the feed simulator will be supplied
// to both the Data and the Matedata Adapters.

try
{
{
LaunchMetaDataProviderServer(null);
}

{
LaunchDataProviderServer(null);
}
}
catch (Exception e)
{
_log.Fatal("Exception caught while starting the server: " + e.Message + ", aborting...", e);
}

_log.Info("My Demo .NET Adapter Custom Server running");
}

private static void Help()
{
_log.Fatal(My Demo .NET Adapter Custom Server Help");
// ....
_log.Fatal("Aborting...");

System.Environment.Exit(9);
}
}

public class ServerStarter : IExceptionHandler
{
private static ILog _log = LogManager.GetLogger("Lightstreamer.Adapters.MyDemo.ServerStarter");

private Server _server;
private bool _closed;

private string _host;
private int _rrPort;
private int _notifPort;

public ServerStarter(string host, int rrPort, int notifPort)
{
_host = host;
_rrPort = rrPort;
_notifPort = notifPort;
}

public void Launch(Server server)
{
_server = server;
_closed = false;
_server.ExceptionHandler = this;
Thread t = new Thread(new ThreadStart(Run));
t.Start();
}

public void Run()
{
TcpClient _rrSocket = null;
TcpClient _notifSocket = null;

do
{
_log.Info("Connecting...");

try
{
_log.Info("Opening connection on port " + _rrPort + "...");
_rrSocket = new TcpClient(_host, _rrPort);
if (_notifPort >= 0)
{
_log.Info("Opening connection on port " + _notifPort + "...");
_notifSocket = new TcpClient(_host, _notifPort);
}

_log.Info("Connected");

break;
}
catch (SocketException)
{
_log.Warn("Connection failed, retrying in 10 seconds...");

Thread.Sleep(10000);
}

} while (true);

_server.RequestStream = _rrSocket.GetStream();
_server.ReplyStream = _rrSocket.GetStream();
if (_notifSocket != null) _server.NotifyStream = _notifSocket.GetStream();

_server.Start();
}

public bool handleIOException(Exception exception)
{
_log.Error("Connection to Lightstreamer Server closed");
_closed = true;
_server.Close();

_log.Info("Type: " + _server.GetType());

if ( _server.GetType().Name.Equals("MetadataProviderServer") )
{
AdaptersLauncher.LaunchMetaDataProviderServer((MetadataProviderServer)_server);
}
else
{
AdaptersLauncher.LaunchDataProviderServer((DataProviderServer)_server);
}

return false;
}

public bool handleException(Exception exception)
{
if (!_closed)
{
_log.Error("Caught exception: " + exception.Message, exception);
_server.Close();
System.Environment.Exit(1);
}
return false;
}

}

}[/SYNTAX]

tvhnet2013

How should I implement RecoveryState() and CleanUp() methods?

Giuseppe Corti

Hi tvhnet2013,

The implementation of these two methods is strictly linked to the logic of your Adapters, and in the extreme case may well not be implemented.

Anyway, in the RecoveyState() method you must provide all the necessary actions in order that the information contained in the old instance of the Adapter that you think is useful to keep, are returned to the new instance.

The CleanUp() method simply must perform any necessary clean and close operations of the resources used prior to its disposal.