public virtual void CloseConnection()
{
IConnectionListener connListener;
ServerManager connManager;
lock (this.connMutex)
{
lock (this.stateMutex)
{
if (this.connManager == null)
{
return;
}
this.phase++;
connManager = this.connManager;
connListener = this.connListener;
}
this.connManager = null;
this.connListener = null;
}
foreach (ITableManager manager2 in connManager.Close())
{
manager2.NotifyUnsub();
}
try
{
connListener.OnClose();
}
catch (Exception)
{
}
}
public virtual void CloseConnection()
{
IConnectionListener closedListener = null;
ServerManager connManager = null;
MyServerListener asyncListener = null;
LSClient subClient = null;
lock (this.connMutex)
{
lock (this.stateMutex)
{
if (this.subClient != null)
{
subClient = this.subClient;
this.subClient = null;
}
else if (this.connManager != null)
{
this.phase++;
connManager = this.connManager;
closedListener = this.connListener;
asyncListener = this.asyncListener;
this.connManager = null;
this.connListener = null;
this.asyncListener = null;
}
else
{
return;
}
}
}
if (subClient != null)
{
subClient.CloseConnection();
}
else
{
foreach (ITableManager manager2 in connManager.Close())
{
manager2.NotifyUnsub();
}
asyncListener.OnClosed(closedListener);
}
}
public virtual void ChangeConstraints(ConnectionConstraints constraints)
{
ServerManager connManager;
try
{
connManager = this.ConnManager;
}
catch (SubscrException)
{
return;
}
try
{
connManager.ChangeConstraints(constraints);
}
catch (PhaseException)
{
}
}
internal virtual Lightstreamer.DotNet.Client.ServerUpdateEvent WaitUpdate(ServerManager.ActivityController activityController)
{
while (true)
{
this.Check();
string pushData = this.WaitCommand(activityController);
if (pushData != null)
{
Lightstreamer.DotNet.Client.ServerUpdateEvent event2;
try
{
event2 = this.serverTranslator.ParsePushData(pushData);
}
catch (PushServerException exception)
{
throw exception;
}
catch (Exception exception2)
{
throw new PushServerException(12, exception2);
}
lock (this)
{
this.totalBytes += pushData.Length + 2;
}
this.Check();
return event2;
}
}
}
private string WaitCommand(ServerManager.ActivityController activityController)
{
string str2;
try
{
string str = this.serverTranslator.WaitCommand(this.pushStream);
activityController.OnActivity();
str2 = str;
}
catch (PushLengthException exception)
{
this.Check();
activityController.StopKeepalives();
throw exception;
}
catch (IOException exception2)
{
this.Check();
throw new PushConnException(exception2);
}
return str2;
}
private string WaitCommand(ServerManager.ActivityController activityController)
{
StreamReader pushStream;
string str2;
PushServerProxy proxy;
lock ((proxy = this))
{
this.Check();
pushStream = this.pushStream;
}
try
{
string str = this.serverTranslator.WaitCommand(pushStream);
activityController.OnActivity();
str2 = str;
}
catch (PushLengthException exception)
{
lock ((proxy = this))
{
this.Check();
this.streamCompleted = true;
}
activityController.StopKeepalives();
throw exception;
}
catch (IOException exception2)
{
lock ((proxy = this))
{
this.Check();
this.streamCompleted = true;
}
throw new PushConnException(exception2);
}
catch (WebException exception3)
{
lock ((proxy = this))
{
this.Check();
this.streamCompleted = true;
}
throw new PushConnException(exception3);
}
return str2;
}
public AnonymousClassTimerTask2(ServerManager.ActivityController enclosingInstance)
{
this.enclosingInstance = enclosingInstance;
}
public AnonymousClassTimerTask(int currPhase, ServerManager.ActivityController enclosingInstance)
{
this.currPhase = currPhase;
this.enclosingInstance = enclosingInstance;
}
public virtual void CloseConnection()
{
IConnectionListener activeListener = null;
ServerManager closingManager = null;
MyServerListener closeListener = null;
LSClient closingSubClient = null;
lock (this.stateMutex)
{
this.phase++;
if (this.subClient != null)
{
closingSubClient = this.subClient;
this.subClient = null;
}
else if (this.connManager != null)
{
closingManager = this.connManager;
activeListener = this.connListener;
closeListener = this.asyncListener;
this.connManager = null;
this.connListener = null;
this.asyncListener = null;
}
else
{
return;
}
}
if (closingSubClient != null)
{
closingSubClient.CloseConnection();
}
else
{
CloseFlushing(closingManager, closeListener, activeListener);
}
}
public MessageParallelizer(BatchMonitor monitor, ServerManager manager)
{
this.monitor = monitor;
monitor.Listener = this;
this.manager = manager;
}
internal virtual Lightstreamer.DotNet.Client.ServerUpdateEvent WaitUpdate(ServerManager.ActivityController activityController)
{
while (true)
{
this.Check();
InfoString pushData = this.WaitCommand(activityController);
if (pushData != null)
{
Lightstreamer.DotNet.Client.ServerUpdateEvent evnt;
if (pushData.value == null)
{
return new Lightstreamer.DotNet.Client.ServerUpdateEvent(pushData.holdingMillis);
}
try
{
evnt = this.serverTranslator.ParsePushData(pushData.value);
}
catch (PushServerException e)
{
throw e;
}
catch (Exception e)
{
throw new PushServerException(12, e);
}
lock (this)
{
this.totalBytes += pushData.value.Length + 2;
}
this.Check();
return evnt;
}
}
}
private InfoString WaitCommand(ServerManager.ActivityController activityController)
{
StreamReader currStream;
InfoString infoString;
PushServerProxy proxy;
lock ((proxy = this))
{
this.Check();
currStream = this.pushStream;
}
try
{
InfoString pushData = this.serverTranslator.WaitCommand(currStream);
if ((pushData != null) && (pushData.value == null))
{
this.Check();
activityController.StopKeepalives();
}
else
{
activityController.OnActivity();
}
infoString = pushData;
}
catch (PushEndException e)
{
lock ((proxy = this))
{
this.Check();
this.streamCompleted = true;
}
throw e;
}
catch (IOException e)
{
lock ((proxy = this))
{
this.Check();
this.streamCompleted = true;
}
throw new PushConnException(e);
}
catch (WebException e)
{
lock ((proxy = this))
{
this.Check();
this.streamCompleted = true;
}
throw new PushConnException(e);
}
return infoString;
}
public virtual void OpenConnection(ConnectionInfo info, IConnectionListener listener)
{
lock (this.connMutex)
{
int num;
object obj3;
this.CloseConnection();
lock ((obj3 = this.stateMutex))
{
num = this.phase + 1;
}
ServerManager.IServerListener asyncListener = new MyServerListener(this, num);
ServerManager manager = new ServerManager(info, listener, asyncListener);
lock ((obj3 = this.stateMutex))
{
this.connListener = listener;
this.phase = num;
this.connManager = manager;
}
manager.Start();
}
}
internal AnonymousClassThread(ServerManager enclosingInstance, string Param1) : base(Param1)
{
this.enclosingInstance = enclosingInstance;
}
public AnonymousClassTimerTask3(bool warningOn, ServerManager.ActivityController enclosingInstance)
{
this.warningOn = warningOn;
this.enclosingInstance = enclosingInstance;
}
private static void CloseFlushing(ServerManager closingManager, MyServerListener closeListener, IConnectionListener activeListener)
{
foreach (ITableManager info in closingManager.Close())
{
info.NotifyUnsub();
}
closeListener.OnClosed(activeListener);
}
public virtual void OpenConnection(ConnectionInfo info, IConnectionListener listener)
{
int currPhase;
object CS$2$0000;
lock ((CS$2$0000 = this.stateMutex))
{
this.CloseConnection();
currPhase = ++this.phase;
}
ConnectionInfo myInfo = (ConnectionInfo) info.Clone();
if (myInfo.EnableStreamSense && !myInfo.Polling)
{
LSClient testClient = new LSClient();
ExtConnectionListener myListener = new ExtConnectionListener(listener);
ConnectionInfo mySubInfo = (ConnectionInfo) info.Clone();
mySubInfo.EnableStreamSense = false;
new Thread(delegate {
try
{
testClient.OpenConnection(mySubInfo, myListener);
}
catch (Exception)
{
}
}) { IsBackground = true }.Start();
if (!myListener.WaitStreamingTimeoutAnswer())
{
lock ((CS$2$0000 = this.stateMutex))
{
if (currPhase == this.phase)
{
this.subClient = testClient;
}
else
{
AsynchCloseConnection(testClient);
return;
}
}
myListener.FlushAndStart();
}
else
{
AsynchCloseConnection(testClient);
lock ((CS$2$0000 = this.stateMutex))
{
if (currPhase != this.phase)
{
return;
}
}
LSClient pollClient = new LSClient();
myInfo.Polling = true;
pollClient.OpenConnection(myInfo, listener);
lock ((CS$2$0000 = this.stateMutex))
{
if (currPhase == this.phase)
{
this.subClient = pollClient;
}
else
{
AsynchCloseConnection(pollClient);
}
}
}
}
else
{
MyServerListener serverListener = new MyServerListener(this, listener, currPhase);
bool ok = false;
try
{
ServerManager newManager = new ServerManager(myInfo, serverListener);
newManager.Connect();
ok = true;
lock ((CS$2$0000 = this.stateMutex))
{
if (currPhase == this.phase)
{
this.connListener = listener;
this.asyncListener = serverListener;
this.connManager = newManager;
}
else
{
CloseFlushing(newManager, serverListener, listener);
return;
}
}
newManager.Start();
}
finally
{
if (!ok)
{
serverListener.OnClosed(null);
}
}
}
}
public virtual void OpenConnection(ConnectionInfo info, IConnectionListener listener)
{
ConnectionInfo info2 = (ConnectionInfo) info.Clone();
info2.useGetForStreaming = true;
lock (this.connMutex)
{
object obj3;
this.CloseConnection();
if (info2.enableStreamSense && !info2.isPolling)
{
ThreadStart start = null;
LSClient testClient = new LSClient();
ExtConnectionListener myListener = new ExtConnectionListener(listener);
ConnectionInfo mySubInfo = (ConnectionInfo) info.Clone();
mySubInfo.enableStreamSense = false;
new Thread(() => {
try
{
testClient.OpenConnection(mySubInfo, myListener);
}
catch (Exception)
{
}
}).Start();
if (!myListener.WaitStreamingTimeoutAnswer())
{
lock ((obj3 = this.stateMutex))
{
this.subClient = testClient;
}
myListener.FlushAndStart();
}
else
{
if (start == null)
{
start = delegate {
testClient.CloseConnection();
};
}
new Thread(start).Start();
LSClient client = new LSClient();
info2.isPolling = true;
client.OpenConnection(info2, listener);
lock ((obj3 = this.stateMutex))
{
this.subClient = client;
}
}
}
else
{
int num;
lock ((obj3 = this.stateMutex))
{
num = this.phase + 1;
}
MyServerListener asyncListener = new MyServerListener(this, listener, num);
bool flag2 = false;
try
{
ServerManager manager = new ServerManager(info2, asyncListener);
manager.Connect();
lock ((obj3 = this.stateMutex))
{
this.connListener = listener;
this.asyncListener = asyncListener;
this.phase = num;
this.connManager = manager;
}
flag2 = true;
manager.Start();
}
finally
{
if (!flag2)
{
asyncListener.OnClosed(null);
}
}
}
}
}
public ActivityController(ServerManager enclosingInstance)
{
this.enclosingInstance = enclosingInstance;
this.streamingConfirmed = enclosingInstance.connInfo.Polling;
}
public virtual void SendMessage(string message)
{
ServerManager connManager;
try
{
connManager = this.ConnManager;
}
catch (SubscrException)
{
return;
}
try
{
connManager.SendMessage(message);
}
catch (PhaseException)
{
}
}
internal SessionActivityManager(ServerManager enclosingInstance, string Param1) : base(Param1)
{
this.enclosingInstance = enclosingInstance;
}
public ActivityController(ServerManager enclosingInstance)
{
this.enclosingInstance = enclosingInstance;
}