diff --git a/src/DataStreamSuite/DataStreamPublisher/DataStreamPublisher.csproj b/src/DataStreamSuite/DataStreamPublisher/DataStreamPublisher.csproj
index 8a974744a..a46e05152 100644
--- a/src/DataStreamSuite/DataStreamPublisher/DataStreamPublisher.csproj
+++ b/src/DataStreamSuite/DataStreamPublisher/DataStreamPublisher.csproj
@@ -3,6 +3,7 @@
+
diff --git a/src/DataStreamSuite/DataStreamPublisher/Program.cs b/src/DataStreamSuite/DataStreamPublisher/Program.cs
index 876814959..3119f167a 100644
--- a/src/DataStreamSuite/DataStreamPublisher/Program.cs
+++ b/src/DataStreamSuite/DataStreamPublisher/Program.cs
@@ -1,16 +1,18 @@
-using bts.utils;
+using System;
-using mbts.config;
+using BCG;
+
+bts.utils.BTSNativeMethods.provide_command_line(new string[] { }, 0);
+mbts.config.Configuration.initialize();
+
+bts.Log.Gen.info($"Starting DSPublisher");
+Console.WriteLine("Starting DSPublisher...");
+// SimpleTCPClient.start("127.0.0.1", 12345);
+// Task.Delay(1000000000).Wait();
+
+//TestPubliser.publish();
+//TestPubliser.subscribe();
+TestPublisher ts = new TestPublisher(false);
+ts.keep_publishing(TimeSpan.FromSeconds(10));
-using System;
-using bts;
-using mbts;
-BTSNativeMethods.provide_command_line(args, args.Length);
-// Must initialize config before using log system
-Console.WriteLine("Initializing config...");
-Configuration.initialize();
-for (int i = 0; i < 10; i++)
-{
- bts.Log.Gen.info($"Starting DataStreamPublisher...log: {i}");
-}
diff --git a/src/DataStreamSuite/PubSub/AllPublishedTagState.cs b/src/DataStreamSuite/PubSub/AllPublishedTagState.cs
index e54eafe9d..cfe6c40ea 100644
--- a/src/DataStreamSuite/PubSub/AllPublishedTagState.cs
+++ b/src/DataStreamSuite/PubSub/AllPublishedTagState.cs
@@ -4,15 +4,13 @@ using System.Collections;
using System.Collections.Generic;
using BCG.Utilities;
-namespace BCG
-{
+namespace BCG {
///
/// Holds the state for a single tag. If the tagType has an
/// IPubSubServerTagHandler, it is updated and the state stored
/// there. Otherwise, this class saves the last published data.
///
- internal class SingleTagHandler
- {
+ internal class SingleTagHandler {
private IPubSubServerTagHandler myHandler = null;
private string myTagType, myTag;
///
@@ -20,9 +18,7 @@ namespace BCG
///
private byte[] myData = null;
- public SingleTagHandler(string tag, string tagType)
- {
-
+ public SingleTagHandler(string tag, string tagType) {
myTagType = tagType;
myTag = tag;
myHandler = TagType2HandlerMap.getHandler(tagType, false);
@@ -30,23 +26,18 @@ namespace BCG
public string tagType { get { return myTagType; } }
- public void publish(Stream data)
- {
+ public void publish(Stream data) {
long pos = data.Position;
- if (myHandler != null)
- {
+ if (myHandler != null) {
myHandler.update(myTag, new Stream[] { data });
- }
- else
- {
+ } else {
myData = new byte[data.Length];
data.Read(myData, 0, myData.Length);
}
data.Position = pos;
}
- public byte[] getContent()
- {
+ public byte[] getContent() {
return myHandler == null ? myData : myHandler.getContent(myTag);
}
}
@@ -54,46 +45,37 @@ namespace BCG
///
/// Keeps the state of all the tags published.
///
- public class AllPublishedTagState
- {
+ public class AllPublishedTagState {
private Dictionary myTagHandler = new Dictionary();
public AllPublishedTagState() { }
- public void publish(string tag, string tagType, Stream data)
- {
+ public void publish(string tag, string tagType, Stream data) {
if (!myTagHandler.ContainsKey(tag))
myTagHandler.Add(tag, new SingleTagHandler(tag, tagType));
myTagHandler[tag].publish(data);
}
- public void publish(string tag, string tagType, byte[] data)
- {
+ public void publish(string tag, string tagType, byte[] data) {
publish(tag, tagType, new MemoryStream(data));
}
- public string[] publishedTags
- { get { return new ArrayList(myTagHandler.Keys).ToArray(typeof(string)) as string[]; } }
+ public string[] publishedTags { get { return new ArrayList(myTagHandler.Keys).ToArray(typeof(string)) as string[]; } }
- public byte[] getContent(string tag, out string tagType)
- {
+ public byte[] getContent(string tag, out string tagType) {
tagType = myTagHandler[tag].tagType;
return myTagHandler[tag].getContent();
}
- public bool contains(string tag)
- {
- return myTagHandler.ContainsKey(tag);
+ public bool contains(string tag) {
+ return myTagHandler.ContainsKey(tag);
}
- public void clear(string tag)
- {
- if (myTagHandler.ContainsKey(tag))
- {
+ public void clear(string tag) {
+ if (myTagHandler.ContainsKey(tag)) {
myTagHandler.Remove(tag);
- }
- else{}
- // BlueEventLog.logEvent("AllPublishTagState told to clear nonexisting tag " + tag, BlueEventLog2Level.Warning);
+ } else { }
+ // BlueEventLog.logEvent("AllPublishTagState told to clear nonexisting tag " + tag, BlueEventLog2Level.Warning);
}
}
diff --git a/src/DataStreamSuite/PubSub/Client/Communication/BlutoTCP/PubSubServerUnmanagedTCPConnection.cs b/src/DataStreamSuite/PubSub/Client/Communication/BlutoTCP/PubSubServerUnmanagedTCPConnection.cs
index 41248b79f..4c341c113 100644
--- a/src/DataStreamSuite/PubSub/Client/Communication/BlutoTCP/PubSubServerUnmanagedTCPConnection.cs
+++ b/src/DataStreamSuite/PubSub/Client/Communication/BlutoTCP/PubSubServerUnmanagedTCPConnection.cs
@@ -1,117 +1,117 @@
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Runtime.InteropServices;
-using mbts;
-//using BCG.Utilities;
+// using System;
+// using System.Collections.Generic;
+// using System.Text;
+// using System.Runtime.InteropServices;
+// using mbts;
+// //using BCG.Utilities;
-namespace BCG
-{
- public class PubSubServerUnmanagedTCPConnection : IPubSubServerConnection
- {
- private BlutoSubAddress myServerAddress;
- private SmartConnectionManagedWrapper myWrapper;
- private ConnectionStatusChange myConnCallback;
- private SyncQueue> myAllMsgsQueue = new SyncQueue>();
+// namespace BCG
+// {
+// public class PubSubServerUnmanagedTCPConnection : IPubSubServerConnection
+// {
+// private BlutoSubAddress myServerAddress;
+// private SmartConnectionManagedWrapper myWrapper;
+// private ConnectionStatusChange myConnCallback;
+// private SyncQueue> myAllMsgsQueue = new SyncQueue>();
- public PubSubServerUnmanagedTCPConnection(string serverURL, SmartConnectionManagedWrapper wrapper)
- {
- myServerAddress = new BlutoSubAddress(serverURL);
- myWrapper = wrapper;
- myWrapper.initConnection(new BlutoSubAddress(serverURL));
- myWrapper.resgisterDataCallback(myServerAddress, new SmartConnectionManagedWrapper.MessageDelegate(myHandleServerMessages));
- }
+// public PubSubServerUnmanagedTCPConnection(string serverURL, SmartConnectionManagedWrapper wrapper)
+// {
+// myServerAddress = new BlutoSubAddress(serverURL);
+// myWrapper = wrapper;
+// myWrapper.initConnection(new BlutoSubAddress(serverURL));
+// myWrapper.resgisterDataCallback(myServerAddress, new SmartConnectionManagedWrapper.MessageDelegate(myHandleServerMessages));
+// }
- #region IPubSubServerConnection Members
+// #region IPubSubServerConnection Members
- public void sendWithConfirmation(byte[] data, ref string confId)
- {
- //BlueEventLog.logAssert(false, "This function should not be used on this class");
- }
+// public void sendWithConfirmation(byte[] data, ref string confId)
+// {
+// //BlueEventLog.logAssert(false, "This function should not be used on this class");
+// }
- public void send(byte[] data)
- {
- myWrapper.send(myServerAddress, data);
- }
+// public void send(byte[] data)
+// {
+// myWrapper.send(myServerAddress, data);
+// }
- public void send(System.IO.Stream str)
- {
- send (StreamUtilityMethods.getBytesFromStream(str));
- }
+// public void send(System.IO.Stream str)
+// {
+// send (StreamUtilityMethods.getBytesFromStream(str));
+// }
- public IList getUpdates(TimeSpan timeout, int maxElements)
- {
- List> msgs = myAllMsgsQueue.dequeueMultipleElements(Convert.ToInt32 (timeout.TotalMilliseconds), maxElements);
- List rv = new List();
- bool connSet = false;
- foreach (Pair p in msgs)
- {
- int msgType = p.first;
- byte[] msg = p.second;
- if (msgType == 1)
- {
- rv.Add(msg);
- }
- else
- {
- connSet = true;
- string connMsg = "connection to " + myServerAddress.ToString() + (msgType == 2 ? " broken" : " established");
- Console.WriteLine(connMsg);
- myConnCallback(myServerAddress.ToString(), msgType == 3);
- }
- }
- return connSet ? new List() : rv;
- }
-
- public string serverURL
- {
- get { return myServerAddress.ToString(); }
- }
+// public IList getUpdates(TimeSpan timeout, int maxElements)
+// {
+// List> msgs = myAllMsgsQueue.dequeueMultipleElements(Convert.ToInt32 (timeout.TotalMilliseconds), maxElements);
+// List rv = new List();
+// bool connSet = false;
+// foreach (Pair p in msgs)
+// {
+// int msgType = p.first;
+// byte[] msg = p.second;
+// if (msgType == 1)
+// {
+// rv.Add(msg);
+// }
+// else
+// {
+// connSet = true;
+// string connMsg = "connection to " + myServerAddress.ToString() + (msgType == 2 ? " broken" : " established");
+// Console.WriteLine(connMsg);
+// myConnCallback(myServerAddress.ToString(), msgType == 3);
+// }
+// }
+// return connSet ? new List() : rv;
+// }
- public string clientURL
- {
- get { return myWrapper.getClientAsSeenByServer (serverURL); }
- }
+// public string serverURL
+// {
+// get { return myServerAddress.ToString(); }
+// }
- public void registerCallback(ConnectionStatusChange del)
- {
- myConnCallback = del;
- }
+// public string clientURL
+// {
+// get { return myWrapper.getClientAsSeenByServer (serverURL); }
+// }
- public void registerDataCallback(DataDelegate del)
- {
- }
+// public void registerCallback(ConnectionStatusChange del)
+// {
+// myConnCallback = del;
+// }
- public void registerSendConfirmationCallback(SendConfirmationDelegate del)
- {
- }
+// public void registerDataCallback(DataDelegate del)
+// {
+// }
- #endregion
+// public void registerSendConfirmationCallback(SendConfirmationDelegate del)
+// {
+// }
- #region IDisposable Members
+// #endregion
- public void Dispose()
- {
-
- }
+// #region IDisposable Members
- #endregion
+// public void Dispose()
+// {
- #region IWorker Members
- public void doWork()
- {
- }
- #endregion
+// }
- ///
- /// this is the only method that it executed on
- /// a different thread
- ///
- ///
- ///
- private void myHandleServerMessages(int msgType, byte[] msg)
- {
- myAllMsgsQueue.enqueue(new Pair(msgType, msg));
- }
- }
-}
+// #endregion
+
+// #region IWorker Members
+// public void doWork()
+// {
+// }
+// #endregion
+
+// ///
+// /// this is the only method that it executed on
+// /// a different thread
+// ///
+// ///
+// ///
+// private void myHandleServerMessages(int msgType, byte[] msg)
+// {
+// myAllMsgsQueue.enqueue(new Pair(msgType, msg));
+// }
+// }
+// }
diff --git a/src/DataStreamSuite/PubSub/Client/Communication/IPubSubServerConnection.cs b/src/DataStreamSuite/PubSub/Client/Communication/IPubSubServerConnection.cs
index 3a24e85e9..132248260 100644
--- a/src/DataStreamSuite/PubSub/Client/Communication/IPubSubServerConnection.cs
+++ b/src/DataStreamSuite/PubSub/Client/Communication/IPubSubServerConnection.cs
@@ -4,8 +4,7 @@ using System.Text;
using System.IO;
using BCG.Utilities.General;
-namespace BCG
-{
+namespace BCG {
///
/// This is the interface that both the PublisherCore and the
/// SubscriberCore use to communicate with the PubsubServer.
@@ -20,22 +19,23 @@ namespace BCG
/// multiple threads need to communicate to the PubSub, they
/// should create their own Subscribers.
///
- public interface IPubSubServerConnection : IDisposable, IWorker
- {
+ public interface IPubSubServerConnection : IDisposable, IWorker {
///
/// The delegate is fired signalling if the data send was
/// successful or not
///
- void sendWithConfirmation(byte[] data, ref string confId);
+ //void sendWithConfirmation(byte[] data, ref string confId);
///
/// send is a non waiting call with no guarantee
/// of data being delivered
///
- void send (byte[] data);
- ///
- /// similiar to above
- ///
+ // void send(byte[] data);
+ // ///
+ // /// similiar to above
+ // ///
void send(Stream str);
+ void send(PubSubMessage msg);
+ void send_with_confirmation(PubSubMessage msg, ref string confId);
///
/// Returns with 0 or more elements, iff the timeout
/// expires or maxElements have been reached (selective polling),
@@ -51,13 +51,13 @@ namespace BCG
///
/// server URL to which the connection is made
///
- string serverURL { get;}
+ string serverURL { get; }
///
/// client URL as seen by the server. if a connection has not
/// been established (as can happen in TCP) an empty string
/// is returned
///
- string clientURL { get;}
+ string clientURL { get; }
///
/// registers the callback to receive
diff --git a/src/DataStreamSuite/PubSub/Client/Communication/ManagedTCP/PubSubServerManagedTCPConnection.cs b/src/DataStreamSuite/PubSub/Client/Communication/ManagedTCP/PubSubServerManagedTCPConnection.cs
index 8117a0ae1..32d5ebc96 100644
--- a/src/DataStreamSuite/PubSub/Client/Communication/ManagedTCP/PubSubServerManagedTCPConnection.cs
+++ b/src/DataStreamSuite/PubSub/Client/Communication/ManagedTCP/PubSubServerManagedTCPConnection.cs
@@ -25,48 +25,64 @@ namespace BCG
ITCPMessageHandler,
ITCPConnectionHandler
{
- private ITCPConnection myConnection, myTempNewConnection;
- private BlutoSubAddress myServerAddress;
- private ThreadSafeQueue> myConfs = new ThreadSafeQueue>();
- private SyncQueue myDataQueue = new SyncQueue();
- private DateTime myLastHB = DateTime.Now;
- private ConnectionStatusChange myConnCallback;
- private DataDelegate myDataCallback;
- private SendConfirmationDelegate myOnSendConfirmCallback;
- private TimeSpan myConnectionDropThreshold =
+ private ITCPConnection _connection, _new_connection;
+ private readonly BlutoSubAddress _server_address;
+ // if a message(with confirm) can not be sent , its id is queued here,
+ // on reconnection, _on_send_onfirm_callback is fired with a negative on these ids, so the user
+ //can re-send it. The re-send mechanism is not in implemented in this class, but by the user of this class
+ private ThreadSafeQueue _negative_unsent_confs = new ThreadSafeQueue();
+ // in onData, data is queued here
+ private SyncQueue _in_data_queue = new SyncQueue();
+ private DateTime _last_hb = DateTime.Now;
+ private ConnectionStatusChange _conn_callback;
+ private DataDelegate _data_callback;
+ private SendConfirmationDelegate _on_send_onfirm_callback;
+ private readonly TimeSpan _connection_drop_threshold =
new TimeSpan(0, 0, 0, 0, PubSub3Config.instance.PS3_HeartBeatInterval * PubSub3Config.instance.PS3_MissingHeartBeatsForGC);
public PubSubServerManagedTCPConnection(string serverURL)
: this(new BlutoSubAddress(serverURL)) { }
- public PubSubServerManagedTCPConnection(BlutoSubAddress serverAddress)
+ public PubSubServerManagedTCPConnection(BlutoSubAddress server_address)
{
- myServerAddress = serverAddress;
- ClientToServerManagedTCPConnector.connectTo(serverAddress, this);
+ _server_address = server_address;
+ _connect_to_ps_server();
+ }
+
+ private void _connect_to_ps_server()
+ {
+ bts.Log.Gen.info($"PubSubServerManagedTCPConnection._connect_to_ps_server server: {_server_address}");
+ ClientToServerManagedTCPConnector.connect_to(_server_address, this, TimeSpan.FromSeconds(1));
}
#region IPubSubServerConnection Members
- public void sendWithConfirmation(byte[] data, ref string confId)
+ public void sendWithConfirmation(byte[] data, ref string conf_id)
{
- if (myConnection != null)
+ bts.Log.Gen.info($"PubSubServerManagedTCPConnection.sendWithConfirmation server: {_server_address} data: {data.Length} myConnection : {_connection != null}");
+ if (_connection != null)
{
- myConnection.sendWithConfirmation(data, ref confId, new SendConfirmationDelegate(myOnSendConfirm));
+ _connection.sendWithConfirmation(data, ref conf_id, (msg_id, confirmed) =>
+ {
+ if (_on_send_onfirm_callback != null)
+ _on_send_onfirm_callback(msg_id, confirmed);
+ });
}
else
{
- confId = Guid.NewGuid().ToString();
- myConfs.enqueue(new Pair(confId, false));
+ bts.Log.Gen.warn($"PubSubServerManagedTCPConnection.sendWithConfirmation server: {_server_address} no connection, buffering send");
+ conf_id = Guid.NewGuid().ToString();
+ _negative_unsent_confs.enqueue(conf_id);
}
}
public void send(byte[] data)
{
- Console.WriteLine($"PubSubServerManagedTCPConnection.send server: {myServerAddress} data: {data.Length} myConnection : {myConnection != null}");
- if (myConnection != null)
+ bts.Log.Gen.info($"PubSubServerManagedTCPConnection.send server: {_server_address} data: {data.Length} myConnection : {_connection != null}");
+ if (_connection != null)
{
- Console.WriteLine("PubSubServerManagedTCPConnection.send server: " + myServerAddress + "data: " + data.Length);
- myConnection.send(data);
+ bts.Log.Gen.info("PubSubServerManagedTCPConnection.send server: " + _server_address + "data: " + data.Length);
+ _connection.send(data);
}
}
@@ -76,14 +92,25 @@ namespace BCG
send(br.ReadBytes(Convert.ToInt32(str.Length - str.Position)));
}
+ public void send(PubSubMessage msg)
+ {
+ send(msg.to_stream());
+ }
+
+ public void send_with_confirmation(PubSubMessage msg, ref string conf_id)
+ {
+ var bytes = msg.to_bytes();
+ sendWithConfirmation(bytes, ref conf_id);
+ }
+
public IList getUpdates(TimeSpan timeout, int maxElements)
{
- return myDataQueue.dequeueMultipleElements(Convert.ToInt32(timeout.TotalMilliseconds), maxElements);
+ return _in_data_queue.dequeueMultipleElements(Convert.ToInt32(timeout.TotalMilliseconds), maxElements);
}
public string serverURL
{
- get { return myServerAddress.ToString(); }
+ get { return _server_address.ToString(); }
}
public string clientURL
@@ -93,7 +120,7 @@ namespace BCG
string rv = "";
lock (this)
{
- if (myConnection == null)
+ if (_connection == null)
{
rv = "";
}
@@ -103,7 +130,7 @@ namespace BCG
{
string ip;
int port;
- myConnection.getSelfAddress(out ip, out port);
+ _connection.getSelfAddress(out ip, out port);
rv = new BlutoSubAddress(ip, port).ToString();
}
else
@@ -118,40 +145,40 @@ namespace BCG
public void registerCallback(ConnectionStatusChange del)
{
- myConnCallback = del;
+ _conn_callback = del;
}
public void registerDataCallback(DataDelegate del)
{
- myDataCallback = del;
+ _data_callback = del;
}
public void registerSendConfirmationCallback(SendConfirmationDelegate del)
{
- myOnSendConfirmCallback = del;
+ _on_send_onfirm_callback = del;
}
#endregion
#region IDisposable Members
- private bool myIsDisposed = false;
+ private bool _is_disposed = false;
public void Dispose()
{
- Console.WriteLine("PubSubServerManagedTCPConnection.Dispose");
+ bts.Log.Gen.info("PubSubServerManagedTCPConnection.Dispose");
//throw new Exception("The method or operation is not implemented.");
- if (myConnection != null)
+ if (_connection != null)
{
- (myConnection as AsyncTCPConnection).Dispose();
+ _connection.Dispose();
}
- myIsDisposed = true;
+ _is_disposed = true;
}
public bool isDisposed
{
get
{
- return myIsDisposed;
+ return _is_disposed;
}
}
@@ -168,17 +195,40 @@ namespace BCG
///
public void onData(RemoteMessage message)
{
- Console.WriteLine($"PubSubServerManagedTCPConnection.onData msg:type: {message.messageType}");
- if (message.messageType == RemoteMessageType.data)
+ bts.Log.Gen.info($"PubSubServerManagedTCPConnection.onData message: {message}");
+ // TODO check for disconenction
+ switch (message.messageType)
{
- if (myDataCallback != null)
- myDataCallback(message.remoteConnectionInfo.ToString(), message.message);
+ case RemoteMessageType.Data:
+ if (_data_callback != null)
+ _data_callback(message.remoteConnectionInfo.ToString(), message.message);
+ else
+ _in_data_queue.enqueue(message.message);
+ break;
+ case RemoteMessageType.Heartbeat:
+ _last_hb = DateTime.Now;
+ break;
+ case RemoteMessageType.Connection:
+ _conn_callback(_server_address.ToString(), true);
+ break;
+ case RemoteMessageType.Disconnection:
+ if (_conn_callback != null)
+ _conn_callback(_server_address.ToString(), false);
+ _connection.Dispose();
+ _connect_to_ps_server();
+ break;
+
+ }
+ if (message.messageType == RemoteMessageType.Data)
+ {
+ if (_data_callback != null)
+ _data_callback(message.remoteConnectionInfo.ToString(), message.message);
else
- myDataQueue.enqueue(message.message);
+ _in_data_queue.enqueue(message.message);
}
else
{
- myLastHB = DateTime.Now;
+ _last_hb = DateTime.Now;
}
}
@@ -197,16 +247,56 @@ namespace BCG
int port;
connection.getPeerAddress(out ip, out port);
BlutoSubAddress add = new BlutoSubAddress(ip, port);
- Console.WriteLine($"PubSubServerManagedTCPConnection.onConnection add: {add.ToString()}");
- if (add.ToString() == myServerAddress.ToString())
+ bts.Log.Gen.info($"PubSubServerManagedTCPConnection.onConnection add: {add.ToString()} connection type: {connection.GetType()}");
+ if (add.ToString() == _server_address.ToString())
{
- myLastHB = DateTime.Now;
- myTempNewConnection = connection;
+ _last_hb = DateTime.Now;
+ _new_connection = connection;
}
}
#endregion
+ void _dispose_and_reconnect_if_missing_hb()
+ {
+ if (!_connection.isDisposed)
+ {
+ TimeSpan hb_interval = DateTime.Now - _last_hb;
+ bool hb_missed = hb_interval > _connection_drop_threshold;
+ if (hb_missed)
+ {
+ if (_conn_callback != null)
+ _conn_callback(_server_address.ToString(), false);
+ bts.Log.Gen.info("PubSubServerManagedTCPConnection._dispose_and_reconnect_if_missing_hb disposing connecion: {myServerAddress}");
+ _connection.Dispose();
+ _connect_to_ps_server();
+ }
+ }
+ else
+ {
+ // already disposed, nothing to do
+ }
+ }
+
+ void _check_for_new_connection()
+ {
+ if (_new_connection != null)
+ {
+ _connection = _new_connection;
+ _new_connection = null; // since we are using its presence as a marker of nw connections
+ bts.Log.Gen.info("PubSubServerManagedTCPConnection._check_for_new_connection assigning new connection");
+ _connection.register(this);
+ if (_conn_callback != null)
+ _conn_callback(_server_address.ToString(), true);
+ if (_on_send_onfirm_callback != null)
+ {
+ var msg_ids = _negative_unsent_confs.dequeueAll();
+ foreach (var id in msg_ids)
+ _on_send_onfirm_callback(id, false);
+ }
+ }
+ }
+
#region IWorker Members
///
@@ -216,55 +306,56 @@ namespace BCG
///
public void doWork()
{
+ //_dispose_and_reconnect_if_missing_hb();
+ _check_for_new_connection();
///check for heartbeats and let clients know in
///case of missing hb (connection breaking)
- TimeSpan curr_hb_interval = DateTime.Now - myLastHB;
- bool hb_missed = curr_hb_interval > myConnectionDropThreshold;
- bool conn_disposed = myConnection != null && myConnection.isDisposed;
- if (conn_disposed || hb_missed)
- {
- if (hb_missed)
- {
- // since conn breakage was diagnosed logically, lets physically close the connection
- myConnection.Dispose();
- string dispose_msg = $"PubSubServerManagedTCPConnection.doWork server: {myServerAddress} Disposing connection conn_disposed: {conn_disposed} hb_missed: {hb_missed}";
- Console.WriteLine(dispose_msg);
- }
- myConnection = null; // this is used as a marker for a dead connection
- if (myConnCallback != null)
- myConnCallback(myServerAddress.ToString(), false);
- string reconn_msg = $"PubSubServerManagedTCPConnection.doWork disconnecting client from server: {myServerAddress} conn_disposed: {conn_disposed} hb_missed: {hb_missed} " +
- $"because of missing hbs last_hb: {myLastHB}, now: {DateTime.Now} curr_hb_interval: {curr_hb_interval.TotalSeconds} threshold: {myConnectionDropThreshold.TotalSeconds} conn_disposed: {conn_disposed}";
- Console.WriteLine(reconn_msg);
- ClientToServerManagedTCPConnector.connectTo(myServerAddress, this);
- }
- if (myTempNewConnection != null)
- {
- if (myConnection != null)
- {
- // TODOds
- // log error and close it
- // BlueEventLog.logAssert(myConnection == null, "Connection has to be nulled out and disposed "
- // + " before a new connection is established");
- }
- Console.WriteLine("PubSubServerManagedTCPConnection hooking new connection");
- myConnection = myTempNewConnection;
- myTempNewConnection = null;
- myConnection.register(this);
- myConfs.dequeueAll();
- if (myConnCallback != null)
- myConnCallback(myServerAddress.ToString(), true);
- }
- foreach (Pair p in myConfs.dequeueAll())
- if (myOnSendConfirmCallback != null)
- myOnSendConfirmCallback(p.first, p.second);
+ // TimeSpan hb_interval = DateTime.Now - myLastHB;
+ // bool hb_missed = hb_interval > myConnectionDropThreshold;
+ // bool conn_disposed = myConnection != null || myConnection.isDisposed;
+ // if (conn_disposed || hb_missed)
+ // {
+ // if (hb_missed)
+ // {
+ // // since conn breakage was diagnosed logically, lets physically close the connection
+ // myConnection.Dispose();
+ // string dispose_msg = $"PubSubServerManagedTCPConnection.doWork server: {myServerAddress} Disposing connection conn_disposed: {conn_disposed} hb_missed: {hb_missed}";
+ // Console.WriteLine(dispose_msg);
+ // }
+ // myConnection = null; // this is used as a marker for a dead connection
+ // if (myConnCallback != null)
+ // myConnCallback(myServerAddress.ToString(), false);
+ // string reconn_msg = $"PubSubServerManagedTCPConnection.doWork disconnecting client from server: {myServerAddress} conn_disposed: {conn_disposed} hb_missed: {hb_missed} " +
+ // $"because of missing hbs last_hb: {myLastHB}, now: {DateTime.Now} curr_hb_interval: {hb_interval.TotalSeconds} threshold: {myConnectionDropThreshold.TotalSeconds} conn_disposed: {conn_disposed}";
+ // ClientToServerManagedTCPConnector.connectTo(myServerAddress, this);
+ // }
+ // if (myTempNewConnection != null)
+ // {
+ // if (myConnection != null)
+ // {
+ // // TODOds
+ // // log error and close it
+ // // BlueEventLog.logAssert(myConnection == null, "Connection has to be nulled out and disposed "
+ // // + " before a new connection is established");
+ // }
+ // Console.WriteLine("PubSubServerManagedTCPConnection hooking new connection");
+ // myConnection = myTempNewConnection;
+ // myTempNewConnection = null;
+ // myConnection.register(this);
+ // myConfs.dequeueAll();
+ // if (myConnCallback != null)
+ // myConnCallback(myServerAddress.ToString(), true);
+ // }
+ // foreach (Pair p in myConfs.dequeueAll())
+ // if (myOnSendConfirmCallback != null)
+ // myOnSendConfirmCallback(p.first, p.second);
}
#endregion
- private void myOnSendConfirm(string messageId, bool confirmed)
- {
- myConfs.enqueue(new Pair(messageId, confirmed));
- }
+ // private void myOnSendConfirm(string messageId, bool confirmed) {
+ // _negative_confs.enqueue(new Pair(messageId, confirmed));
+ // }
+
}
}
\ No newline at end of file
diff --git a/src/DataStreamSuite/PubSub/Client/MetaData/MetaData.cs b/src/DataStreamSuite/PubSub/Client/MetaData/MetaData.cs
index 8ee7ff24a..ef1f14a19 100644
--- a/src/DataStreamSuite/PubSub/Client/MetaData/MetaData.cs
+++ b/src/DataStreamSuite/PubSub/Client/MetaData/MetaData.cs
@@ -7,144 +7,116 @@ using System.Text;
using BCG;
-//using BCG.Utilities;
+using System.Collections.Generic;
-namespace BCG
-{
- public class MetaData : ICloneable
- {
- private Hashtable myHash = new Hashtable();
+namespace BCG {
+ // Thhis "wraps" around the following 4 PubSub meta objects, serializes it on the client and
+ // deserialize it on the pubsub
+ // PubMetaData
+ // SubMetaData
+ // TransactionMetaData
+ // UnSubMetaData
+ public class MetaData : ICloneable {
+ private IDictionary _name_value_map = new Dictionary();
int mySize = -1;
- public MetaData()
- {}
+ public MetaData() { }
- public MetaData(object o)
- {copyFrom(o);}
+ public MetaData(object o) { copyFrom(o); }
- public MetaData(Stream s)
- {
+ public MetaData(Stream s) {
long initPos = s.Position;
load(s);
mySize = Convert.ToInt32(s.Position - initPos);
}
- public string this[string name]
- {
- get
- {return (string) myHash[name];}
- set
- {
+ public string this[string name] {
+ get { return (string)_name_value_map[name]; }
+ set {
if (value != null)
- myHash[name] = value;
+ _name_value_map[name] = value;
}
}
- public void add(string name, string [] values)
- {
+ private void _add_string_array(string name, string[] values) {
StringBuilder sb = new StringBuilder();
- foreach (string s in values)
- {
+ foreach (string s in values) {
if (sb.Length != 0)
sb.Append(" ");
sb.Append(s);
}
- myHash[name] = sb.ToString();
+ _name_value_map[name] = sb.ToString();
}
- public int getAsInt(string name)
- {return Int32.Parse(this[name]);}
+ private int getAsInt(string name) { return Int32.Parse(this[name]); }
- public string[] getAsStringArray (string name)
- {
+ private string[] _get_as_string_array(string name) {
if (this[name] != "" && this[name] != null)
return this[name].Split(' ');
else
return new string[0];
}
- public int size()
- {
- if (mySize < 0)
- {
+ public int size() {
+ if (mySize < 0) {
MemoryStream ms = new MemoryStream();
this.save(ms);
return mySize = (int)ms.Position;
- }
- else
+ } else
return mySize;
}
- public bool isEqual (MetaData md)
- {
- if (md.myHash.Keys.Count != myHash.Keys.Count)
+ private bool isEqual(MetaData md) {
+ if (md._name_value_map.Keys.Count != _name_value_map.Keys.Count)
return false;
- foreach (string k in myHash.Keys)
- if (!myHash[k].Equals(md.myHash[k]))
+ foreach (string k in _name_value_map.Keys)
+ if (!_name_value_map[k].Equals(md._name_value_map[k]))
return false;
return true;
}
- public void load(Stream s)
- {
- myHash = new Hashtable();
- string [] state =
+ // loads the content of the stream into this instance's map
+ private void load(Stream s) {
+ _name_value_map = new Hashtable();
+ string[] state =
new BinaryReader(s).ReadString().Split('\n');
- for (int i = 0; i < state.Length-1; i+= 2)
- myHash[state[i]] = state[i+1];
+ for (int i = 0; i < state.Length - 1; i += 2)
+ _name_value_map[state[i]] = state[i + 1];
}
- public void save(Stream s)
- {
+ // writes the content of this instance to stream s
+ public void save(Stream s) {
new BinaryWriter(s).Write(this.ToString());
}
- public override string ToString()
- {
+ public override string ToString() {
StringBuilder sb = new StringBuilder();
- foreach (string key in myHash.Keys)
- sb.AppendFormat("{0}\n{1}\n",key,myHash[key]);
+ foreach (string key in _name_value_map.Keys)
+ sb.AppendFormat("{0}\n{1}\n", key, _name_value_map[key]);
return sb.ToString();
}
- public void copyFrom(object o)
- {
+ // iterates through the fields and enters the name, values into _hash
+ public void copyFrom(object o) {
this["op-code"] = o.GetType().Name;
-
-
-
- foreach (FieldInfo fi in o.GetType().GetFields())
- {
-
+ foreach (FieldInfo fi in o.GetType().GetFields()) {
if (fi.GetValue(o) == null)
continue;
-
else if (fi.GetValue(o) is String[])
- add(fi.Name, (string[])fi.GetValue(o));
-
+ _add_string_array(fi.Name, (string[])fi.GetValue(o));
else
- myHash[fi.Name] = fi.GetValue(o).ToString();
-
+ _name_value_map[fi.Name] = fi.GetValue(o).ToString();
+
}
}
-
- public void copyTo(object o)
- {
-
-
- foreach (FieldInfo fi in o.GetType().GetFields())
- {
-
+ // copies the name value map into object o
+ public void copyTo(object o) {
+ foreach (FieldInfo fi in o.GetType().GetFields()) {
string value = this[fi.Name];
- //this should only be here temporarily, while the new decompression changes are waiting to go into prod.
- if (value == null)
- {
- //BlueEventLog.logEvent("Error: Metadata missing field " + fi.Name, BlueEventLog2Level.MissingMetadata);
- }
- else
- {
+ if (value == null) {
+ } else {
if (fi.FieldType.Equals(typeof(string)))
fi.SetValue(o, value);
else if (fi.FieldType.Equals(typeof(int)))
@@ -167,11 +139,10 @@ namespace BCG
}
}
- public object Clone()
- {
+ public object Clone() {
MemoryStream ms = new MemoryStream();
this.save(ms);
- ms.Seek(0,SeekOrigin.Begin);
+ ms.Seek(0, SeekOrigin.Begin);
return new MetaData(ms);
}
}
diff --git a/src/DataStreamSuite/PubSub/Client/MetaData/RenewMetaData.cs b/src/DataStreamSuite/PubSub/Client/MetaData/RenewMetaData.cs
index d83c76918..a55b4a111 100644
--- a/src/DataStreamSuite/PubSub/Client/MetaData/RenewMetaData.cs
+++ b/src/DataStreamSuite/PubSub/Client/MetaData/RenewMetaData.cs
@@ -1,25 +1,25 @@
-using System;
+// using System;
-namespace BCG
-{
- [Serializable]
- public class RenewMetaData
- {
- public string subscriber;
- public int lease;
- public bool c;
-
- public SubAddress getSubAddress()
- {return SubAddress.decode(subscriber);}
+// namespace BCG
+// {
+// [Serializable]
+// public class RenewMetaData
+// {
+// public string subscriber;
+// public int lease;
+// public bool c;
- public RenewMetaData()
- {}
+// public SubAddress getSubAddress()
+// {return SubAddress.decode(subscriber);}
- public RenewMetaData(string s,
- int lease)
- {
- this.subscriber = s;
- this.lease = lease;
- }
- }
-}
+// public RenewMetaData()
+// {}
+
+// public RenewMetaData(string s,
+// int lease)
+// {
+// this.subscriber = s;
+// this.lease = lease;
+// }
+// }
+// }
diff --git a/src/DataStreamSuite/PubSub/ManagedTCP/AsyncTCPConnection.cs b/src/DataStreamSuite/PubSub/ManagedTCP/AsyncTCPConnection.cs
index 41683d8b3..a5b201e2f 100644
--- a/src/DataStreamSuite/PubSub/ManagedTCP/AsyncTCPConnection.cs
+++ b/src/DataStreamSuite/PubSub/ManagedTCP/AsyncTCPConnection.cs
@@ -8,7 +8,8 @@ using System.IO;
using BCG.Utilities.General;
using System.Runtime.InteropServices;
-namespace BCG {
+namespace BCG
+{
///
/// This class, mantains a connection to a peer socket, using
/// the .Net async TCP library. It sends heartbeats at regular
@@ -28,14 +29,16 @@ namespace BCG {
/// methods indicate an error, missing heartbeats is guaranteed
/// to detect it.
///
- public class AsyncTCPConnection : ITCPConnection, IWorker, IDisposable {
+ public class AsyncTCPConnection : ITCPConnection, IWorker, IDisposable
+ {
///
/// This is used as a state for the Async send. Reason being
/// that if onSend indicates that it could not send the full
/// data (ie EndSend does not return the full size), the offset
/// is used to resend the data
///
- public class AsyncMessage {
+ public class AsyncMessage
+ {
public byte[] buffer;
public int offset;
public string messageId;
@@ -44,7 +47,8 @@ namespace BCG {
public AsyncMessage(byte[] theBuffer, int theOffset)
: this(theBuffer, theOffset, String.Empty, null) { }
- public AsyncMessage(byte[] theBuffer, int theOffset, string theMessageId, SendConfirmationDelegate theOnSendDel) {
+ public AsyncMessage(byte[] theBuffer, int theOffset, string theMessageId, SendConfirmationDelegate theOnSendDel)
+ {
buffer = theBuffer;
offset = theOffset;
messageId = theMessageId;
@@ -52,14 +56,17 @@ namespace BCG {
}
- public int length {
- get {
+ public int length
+ {
+ get
+ {
return buffer.Length - offset;
}
}
}
- enum ReadState {
+ enum ReadState
+ {
readingSize,
readingData
};
@@ -67,13 +74,15 @@ namespace BCG {
#region work around for .Net socket's LocalEndPoint bug
[StructLayout(LayoutKind.Sequential)]
- private struct in_addr {
+ private struct in_addr
+ {
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
public byte[] sin_addr;
}
[StructLayout(LayoutKind.Sequential)]
- private struct sockaddr {
+ private struct sockaddr
+ {
public short sin_family;
public ushort sin_port;
public in_addr sin_addr;
@@ -106,7 +115,8 @@ namespace BCG {
private bool myHBReceived = false, myDataReceived = false, myHBSent = false;
private DateTime myLastHBReceivedTime = new DateTime(1900, 1, 1);
- public AsyncTCPConnection(Socket sock, TimeSpan heartBeatTimeSpan) {
+ public AsyncTCPConnection(Socket sock, TimeSpan heartBeatTimeSpan)
+ {
myHBTimeSpan = heartBeatTimeSpan;
mySock = sock;
mySock.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.DontRoute, true);
@@ -120,24 +130,28 @@ namespace BCG {
// mySelf.ToString(), myPeer.ToString()), PS3LogLevels.connection);
}
- public override string ToString() {
+ public override string ToString()
+ {
return String.Format("peer = {0}, self = {1}", myPeer.ToString(), mySelf.ToString());
}
#region ITCPConnection Members
- public void sendWithConfirmation(byte[] data, ref string confId, SendConfirmationDelegate del) {
+ public void sendWithConfirmation(byte[] data, ref string confId, SendConfirmationDelegate del)
+ {
confId = Guid.NewGuid().ToString();
byte[] msg = myBuildDataMessage(data);
myBeginOrResumeSending(new AsyncMessage(msg, 0, confId, del));
}
- public void send(byte[] data) {
+ public void send(byte[] data)
+ {
byte[] msg = myBuildDataMessage(data);
myBeginOrResumeSending(new AsyncMessage(msg, 0));
}
- public void register(ITCPMessageHandler messageHandler) {
+ public void register(ITCPMessageHandler messageHandler)
+ {
// BlueEventLog.logAssert(myMessageHandler == null, "Message Handler is already assigned");
// BlueEventLog.logEvent(String.Format("AsyncTCPConnection for peer = {0} being registered", myPeer.ToString()),
// PS3LogLevels.connection);
@@ -146,10 +160,12 @@ namespace BCG {
myReadSize();
}
- public void getPeerAddress(out string ip, out int port) {
+ public void getPeerAddress(out string ip, out int port)
+ {
ip = "";
port = 0;
- if (myAlive) {
+ if (myAlive)
+ {
IPEndPoint ipEp = mySock.RemoteEndPoint as IPEndPoint;
ip = ipEp.Address.ToString();
port = ipEp.Port;
@@ -162,10 +178,12 @@ namespace BCG {
//port = addr.sin_port;
}
- public void getSelfAddress(out string ip, out int port) {
+ public void getSelfAddress(out string ip, out int port)
+ {
ip = "";
port = 0;
- if (myAlive) {
+ if (myAlive)
+ {
IPEndPoint ipEp = mySock.LocalEndPoint as IPEndPoint;
ip = ipEp.Address.ToString();
port = ipEp.Port;
@@ -178,7 +196,8 @@ namespace BCG {
//port = addr.sin_port;
}
- public bool isDisposed {
+ public bool isDisposed
+ {
get { return !myAlive; }
}
@@ -187,14 +206,16 @@ namespace BCG {
#region IWorker Members
bool _last_connected = false;
- public void doWork() {
+ public void doWork()
+ {
if (mySock != null)
//if (mySock.Connected != _last_connected)
{
Console.WriteLine($"AsyncTCPConnection.doWork connected: {mySock.Connected}");
_last_connected = mySock.Connected;
}
- if (!myHBSent) {
+ if (!myHBSent)
+ {
// BlueEventLog.logEvent(String.Format("Sending heartbeat to peer {0} for the first time", myPeer.ToString()),
// PS3LogLevels.connection);
myHBSent = true;
@@ -206,9 +227,12 @@ namespace BCG {
#region sending data
- private void myBeginOrResumeSending(AsyncMessage message) {
- if (myAlive) {
- try {
+ private void myBeginOrResumeSending(AsyncMessage message)
+ {
+ if (myAlive)
+ {
+ try
+ {
//Console.WriteLine($"AsyncTCPConnection.myBeginOrResumeSending len: {message.length} connected: {mySock.Connected}");
SocketError beginSendErr;
mySock.BeginSend(message.buffer, message.offset, message.length, SocketFlags.None,
@@ -216,36 +240,50 @@ namespace BCG {
Console.WriteLine($"AsyncTCPConnection.myBeginOrResumeSending len: {message.length} socker_error: {beginSendErr} connected: {mySock.Connected}");
if (beginSendErr != SocketError.Success)
myHandleError(beginSendErr);
- } catch (Exception ex) {
+ }
+ catch (Exception ex)
+ {
myHandleError(ex);
}
}
}
- private void myOnSend(IAsyncResult res) {
- if (myAlive) {
- try {
+ private void myOnSend(IAsyncResult res)
+ {
+ if (myAlive)
+ {
+ try
+ {
SocketError writeErr;
int bytesSent = mySock.EndSend(res, out writeErr);
Console.WriteLine($"AsyncTCPConnection.myOnSend bytes: {bytesSent} writeErr: {writeErr} connected: {mySock.Connected}");
AsyncMessage message = res.AsyncState as AsyncMessage;
message.offset += bytesSent;
- if (writeErr == SocketError.Success) {
- if (message.offset == message.buffer.Length) {
+ if (writeErr == SocketError.Success)
+ {
+ if (message.offset == message.buffer.Length)
+ {
// if confirmation needs to be sent
- if (String.Empty != message.messageId) {
+ if (String.Empty != message.messageId)
+ {
message.onSendDel(message.messageId, true);
}
- } else {
+ }
+ else
+ {
///resume writing rest of the message
// BlueEventLog.logEvent("could not send the whole message all at once , messageSize = " +
// message.buffer.Length + " offset = " + message.offset, PS3LogLevels.info);
myBeginOrResumeSending(message);
}
- } else {
+ }
+ else
+ {
myHandleError(writeErr);
}
- } catch (Exception ex) {
+ }
+ catch (Exception ex)
+ {
myHandleError(ex);
}
}
@@ -256,8 +294,10 @@ namespace BCG {
/// future references
///
///
- private byte[] myBuildHeartbeatMessage() {
- if (myHBMessage == null) {
+ private byte[] myBuildHeartbeatMessage()
+ {
+ if (myHBMessage == null)
+ {
BinaryWriter bw = new BinaryWriter(new MemoryStream());
int sz = 4;
int msgType = 1;
@@ -276,7 +316,8 @@ namespace BCG {
///
///
///
- private byte[] myBuildDataMessage(byte[] data) {
+ private byte[] myBuildDataMessage(byte[] data)
+ {
BinaryWriter bw = new BinaryWriter(new MemoryStream());
bw.Write(data.Length + 8);
bw.Write(0);
@@ -289,25 +330,31 @@ namespace BCG {
#region receiving data
- private void myReadSize() {
+ private void myReadSize()
+ {
myCurrentReadBuffer = new byte[4];
myCurrentReadBufferOffset = 0;
myCurrentReadState = ReadState.readingSize;
myBeginOrResumeReading();
}
- private void myReadData(int dataSize) {
+ private void myReadData(int dataSize)
+ {
myCurrentReadBuffer = new byte[dataSize];
myCurrentReadBufferOffset = 0;
myCurrentReadState = ReadState.readingData;
myBeginOrResumeReading();
}
- private void myBeginOrResumeReading() {
- if (myAlive) {
- try {
+ private void myBeginOrResumeReading()
+ {
+ if (myAlive)
+ {
+ try
+ {
int beginReceiveAttempts = 0;
- while (true) {
+ while (true)
+ {
beginReceiveAttempts++;
SocketError readSockErr;
mySock.BeginReceive(myCurrentReadBuffer, myCurrentReadBufferOffset,
@@ -316,7 +363,8 @@ namespace BCG {
new AsyncCallback(myOnRead),
myCurrentReadBuffer);
Console.WriteLine($"AsyncTCPConnection.myBeginOrResumeReading socket_error: {readSockErr} connected: {mySock.Connected}");
- if (readSockErr == SocketError.NoBufferSpaceAvailable) {
+ if (readSockErr == SocketError.NoBufferSpaceAvailable)
+ {
string msg = String.Format("Not enough buffer space to receive {0} bytes. Attempt: {1} of {2}.",
myCurrentReadBuffer.Length - myCurrentReadBufferOffset,
beginReceiveAttempts, PubSub3Config.instance.PS3_retriesOnNoBufferSpace + 1);
@@ -324,81 +372,108 @@ namespace BCG {
if (beginReceiveAttempts < (PubSub3Config.instance.PS3_retriesOnNoBufferSpace + 1))
System.Threading.Thread.Sleep(PubSub3Config.instance.PS3_millisecondsBetweenNoBufferSpaceRetries);
- else {
+ else
+ {
//BlueEventLog.logEvent("Could not recover from NoBufferSpace condition. Breaking connection.", PS3LogLevels.disconnection);
myHandleError(readSockErr);
}
- } else if (readSockErr == SocketError.Success) {
+ }
+ else if (readSockErr == SocketError.Success)
+ {
if (beginReceiveAttempts > 1)
// BlueEventLog.logEvent(String.Format("Recovered from NoBufferSpace after {0} tries",beginReceiveAttempts-1) ,
// PS3LogLevels.disconnection);
break;
- } else
+ }
+ else
myHandleError(readSockErr);
}
- } catch (Exception ex) {
+ }
+ catch (Exception ex)
+ {
myHandleError(ex);
}
}
}
- private void myOnRead(IAsyncResult res) {
- if (myAlive) {
- try {
+ private void myOnRead(IAsyncResult res)
+ {
+ if (myAlive)
+ {
+ try
+ {
SocketError readErr;
Console.WriteLine($"AsyncTCPConnection.myOnRead pre connected: {mySock.Connected}");
int bytesRead = mySock.EndReceive(res, out readErr);
Console.WriteLine($"AsyncTCPConnection.myOnRead bytes: {bytesRead} readErr: {readErr} connected: {mySock.Connected}");
myCurrentReadBufferOffset += bytesRead;
- if (readErr == SocketError.Success) {
- if (myCurrentReadBufferOffset == myCurrentReadBuffer.Length) {
+ if (readErr == SocketError.Success)
+ {
+ if (myCurrentReadBufferOffset == myCurrentReadBuffer.Length)
+ {
///read the whole of the buffer
- if (myCurrentReadState == ReadState.readingSize) {
+ if (myCurrentReadState == ReadState.readingSize)
+ {
///the size has already been read, now convert
///it into an int, and start reading the data
int dataSize = new BinaryReader(new MemoryStream(myCurrentReadBuffer)).ReadInt32();
- if (dataSize > myMaxMessageSize) {
+ if (dataSize > myMaxMessageSize)
+ {
string errMessage = "Encountered malformed message, size indicated = " + dataSize;
//BlueEventLog.logEvent(errMessage, "Error");
myHandleError(new ApplicationException(errMessage));
- } else
+ }
+ else
myReadData(dataSize);
- } else {
+ }
+ else
+ {
///the whole data has been finally read, time to
///tell the subscriber about it
BinaryReader br = new BinaryReader(new MemoryStream(myCurrentReadBuffer));
int msgType = br.ReadInt32();
- if (msgType == 0) {
+ if (msgType == 0)
+ {
///skips the message ID
br.ReadInt32();
byte[] data = br.ReadBytes(myCurrentReadBuffer.Length - 8);
///callbacks can be made through thread pool to avoid this
///thread from being blocked, by this callback
- if (!myDataReceived) {
+ if (!myDataReceived)
+ {
myDataReceived = true;
Console.WriteLine($"AsyncTCPConnection Data received for the first time from peer {myPeer.ToString()}");
}
- myMessageHandler.onData(new RemoteMessage(data, RemoteMessageType.data, myPeer));
+ myMessageHandler.onData(new RemoteMessage(data, RemoteMessageType.Data, myPeer));
- } else if (msgType == 1) {
- if (!myHBReceived) {
+ }
+ else if (msgType == 1)
+ {
+ if (!myHBReceived)
+ {
myHBReceived = true;
Console.WriteLine($"AsyncTCPConnection HB received for the first time from peer {myPeer.ToString()}");
}
myLastHBReceivedTime = DateTime.Now;
- myMessageHandler.onData(new RemoteMessage(null, RemoteMessageType.heartbeat, myPeer));
+ myMessageHandler.onData(new RemoteMessage(null, RemoteMessageType.Heartbeat, myPeer));
}
myReadSize();
}
- } else {
+ }
+ else
+ {
///still part of the buffer left to read
///continue reading
myBeginOrResumeReading();
}
- } else {
+ }
+ else
+ {
myHandleError(readErr);
}
- } catch (Exception ex) {
+ }
+ catch (Exception ex)
+ {
myHandleError(ex);
}
}
@@ -408,18 +483,24 @@ namespace BCG {
#region IDisposable Members
- public void Dispose() {
+ public void Dispose()
+ {
Console.WriteLine("AsyncTCPConnection.Dispose()");
- lock (this) {
- if (myAlive) {
+ lock (this)
+ {
+ if (myAlive)
+ {
myMasterWorker.removeWorker(this);
myAlive = false;
// BlueEventLog.logEvent(String.Format("AsycnTCPConnection with peer {0} being disposed, last HB was received at {1}" ,
// myPeer.ToString(), myLastHBReceivedTime.ToLongTimeString()),
// PS3LogLevels.disconnection);
- try {
+ try
+ {
mySock.Close();
- } catch (Exception ex) {
+ }
+ catch (Exception ex)
+ {
String.Format("Exception of type {0} thrown while trying to close socket connected to {1} , with" +
" the following exception msg {2}", ex.GetType().ToString(), myPeer.ToString(), ex.Message);
//BlueEventLog.logEvent(ex);
@@ -432,21 +513,27 @@ namespace BCG {
#endregion
- private void myHandleError(object err) {
- lock (this) {
+ private void myHandleError(object err)
+ {
+ lock (this)
+ {
string errMsg = "";
- if (err is Exception) {
+ if (err is Exception)
+ {
errMsg = String.Format("AsyncTCPConnection.Dispose Encountered an exception of type '{0}' on the socket connected to ip = {1} , port = {2} ; " +
"Exception message = {3} , if the socket has not been disposed, it will be disposed now", err.GetType(), myPeer.ip, myPeer.port, (err as Exception).Message);
if (err is OutOfMemoryException)
throw (err as OutOfMemoryException);
- } else if (err is SocketError) {
+ }
+ else if (err is SocketError)
+ {
errMsg = String.Format("AsyncTCPConnection.Dispose Encountered a SocketError of type '{0}' on the socket connected to ip = {1} , port = {2} ; " +
"if the socket has not been disposed, it will be disposed now", err.ToString(), myPeer.ip, myPeer.port);
Console.WriteLine($"AsyncTCPConnection.myHandleError errMsg: {errMsg}");
}
//BlueEventLog.logEvent(errMsg, PS3LogLevels.disconnection);
- if (myAlive) {
+ if (myAlive)
+ {
Dispose();
}
}
diff --git a/src/DataStreamSuite/PubSub/ManagedTCP/AsyncTCPConnection2.cs b/src/DataStreamSuite/PubSub/ManagedTCP/AsyncTCPConnection2.cs
index 28d72db0e..cc71ad7f4 100644
--- a/src/DataStreamSuite/PubSub/ManagedTCP/AsyncTCPConnection2.cs
+++ b/src/DataStreamSuite/PubSub/ManagedTCP/AsyncTCPConnection2.cs
@@ -119,7 +119,7 @@ namespace BCG
try
{
byte[] msg = await TCPSocketUtils.read_bytes_async(_nw_stream);
- //Console.WriteLine($"_keep_reading sz: {msg.Length}");
+ bts.Log.Gen.info($"AsyncTCPConnection2._keep_reading side: {_side} self: {get_self_address()} peer: {get_peer_address} msg len: {msg.Length}");
await _handle_msg(msg);
}
catch (Exception ex)
@@ -139,12 +139,12 @@ namespace BCG
if (msg_type == _msg_type_data)
{
byte[] data = br.ReadBytes(msg.Length - 1);
- RemoteMessage m = new RemoteMessage(data, RemoteMessageType.data, _peer_address);
+ RemoteMessage m = new RemoteMessage(data, RemoteMessageType.Data, _peer_address);
_message_handler.onData(m);
}
else
{
- RemoteMessage m = new RemoteMessage(null, RemoteMessageType.heartbeat, _peer_address);
+ RemoteMessage m = new RemoteMessage(null, RemoteMessageType.Heartbeat, _peer_address);
_message_handler.onData(m);
}
}
@@ -174,7 +174,7 @@ namespace BCG
bts.Log.Gen.error($"TCPConnection._handle_error got exception when closing Socket ex: {ex}");
}
_is_disposed = true;
- RemoteMessage rm = new RemoteMessage(new byte[] { }, RemoteMessageType.disconnection, _peer_address);
+ RemoteMessage rm = new RemoteMessage(new byte[] { }, RemoteMessageType.Disconnection, _peer_address);
_message_handler.onData(rm);
}
@@ -194,14 +194,17 @@ namespace BCG
}
}
- public void sendWithConfirmation(byte[] data, ref string confId, SendConfirmationDelegate del)
+ public void sendWithConfirmation(byte[] data, ref string conf_id, SendConfirmationDelegate del)
{
- confId = String.Empty;
+ conf_id = (++_msg_id).ToString();
+ send(data);
+ del(conf_id, true);
}
public void send(byte[] data)
{
Task.Run(async () => await send_async(data));
+ bts.Log.Gen.info($"AsyncTCPConnection2.send self: {get_self_address()} peer: {get_peer_address} msg len: {data.Length} sent successfully");
//_data_send_queue.enqueue(new QueuedMessage(data));
}
@@ -242,6 +245,13 @@ namespace BCG
return new RemoteConnectionInfo(ip, port);
}
+ public RemoteConnectionInfo get_self_address()
+ {
+ string ip; int port;
+ getSelfAddress(out ip, out port);
+ return new RemoteConnectionInfo(ip, port);
+ }
+
public void getSelfAddress(out string ip, out int port)
{
@@ -269,7 +279,9 @@ namespace BCG
public void Dispose()
{
-
+ _nw_stream.Close();
+ _nw_stream.Dispose();
+ _is_disposed = true;
}
public bool isDisposed
diff --git a/src/DataStreamSuite/PubSub/ManagedTCP/RemoteMessage.cs b/src/DataStreamSuite/PubSub/ManagedTCP/RemoteMessage.cs
index f7b64eeda..ccfc9a11d 100644
--- a/src/DataStreamSuite/PubSub/ManagedTCP/RemoteMessage.cs
+++ b/src/DataStreamSuite/PubSub/ManagedTCP/RemoteMessage.cs
@@ -2,12 +2,14 @@ using System;
using System.Collections.Generic;
using System.Text;
-namespace BCG {
+namespace BCG
+{
///
/// Type of messages that can be sent over the transport.
///
- public enum RemoteMessageType {
- heartbeat, data, connection, disconnection
+ public enum RemoteMessageType
+ {
+ Heartbeat, Data, Connection, Disconnection
}
///
@@ -15,30 +17,36 @@ namespace BCG {
/// This can be a transport generated message (heartbeat) or user generated
/// message (data)
///
- public class RemoteMessage {
+ public class RemoteMessage
+ {
private byte[] myMsg;
private RemoteMessageType myMsgType;
private RemoteConnectionInfo myConnInfo;
- public RemoteMessage(byte[] message, RemoteMessageType messageType, RemoteConnectionInfo connInfo) {
+ public RemoteMessage(byte[] message, RemoteMessageType messageType, RemoteConnectionInfo connInfo)
+ {
myMsg = message;
myMsgType = messageType;
myConnInfo = connInfo;
}
- public byte[] message {
+ public byte[] message
+ {
get { return myMsg; }
}
- public RemoteMessageType messageType {
+ public RemoteMessageType messageType
+ {
get { return myMsgType; }
}
- public RemoteConnectionInfo remoteConnectionInfo {
+ public RemoteConnectionInfo remoteConnectionInfo
+ {
get { return myConnInfo; }
}
- override public string ToString() {
+ override public string ToString()
+ {
Func len = (byte[] m) => { return m == null ? 0 : m.Length; };
return $"type: {myMsgType} conn: {myConnInfo} msg: {len(myMsg)}";
}
diff --git a/src/DataStreamSuite/PubSub/ManagedTCP/ServerToClientManagedTCPConnectionAcceptor.cs b/src/DataStreamSuite/PubSub/ManagedTCP/ServerToClientManagedTCPConnectionAcceptor.cs
index 53dbe83ec..155637930 100644
--- a/src/DataStreamSuite/PubSub/ManagedTCP/ServerToClientManagedTCPConnectionAcceptor.cs
+++ b/src/DataStreamSuite/PubSub/ManagedTCP/ServerToClientManagedTCPConnectionAcceptor.cs
@@ -44,9 +44,9 @@ namespace BCG {
// BlueEventLog.logEvent(msg, BlueEventLog2Level.Error);
return port;
} else {
- SingleServerToClientManagedTCPConnectionAcceptor theAcceptor = new SingleServerToClientManagedTCPConnectionAcceptor();
- int assignedport = theAcceptor.activate(handler, port, clientHBTimeSpan);
- myPortToSingleServerAcceptorMap[assignedport] = theAcceptor;
+ SingleServerToClientManagedTCPConnectionAcceptor ps_acceptor = new SingleServerToClientManagedTCPConnectionAcceptor();
+ int assignedport = ps_acceptor.accept_on_port(handler, "127.0.0.1", port, clientHBTimeSpan);
+ myPortToSingleServerAcceptorMap[assignedport] = ps_acceptor;
return assignedport;
}
} //end lock
diff --git a/src/DataStreamSuite/PubSub/ManagedTCP/SingleServerToClientManagedTCPConnectionAcceptor.cs b/src/DataStreamSuite/PubSub/ManagedTCP/SingleServerToClientManagedTCPConnectionAcceptor.cs
index 2ec8ebfca..291430b04 100644
--- a/src/DataStreamSuite/PubSub/ManagedTCP/SingleServerToClientManagedTCPConnectionAcceptor.cs
+++ b/src/DataStreamSuite/PubSub/ManagedTCP/SingleServerToClientManagedTCPConnectionAcceptor.cs
@@ -68,7 +68,7 @@ namespace BCG {
return myPort; // not sure why we need this class variable myPort, but I am just keeping it up with the existing code
}
- public int accept_on_port(ITCPConnectionHandler handler, string ip, int port, TimeSpan clientHBTimeSpan) {
+ public int accept_on_port(ITCPConnectionHandler handler, string ip, int port, TimeSpan client_HB_timespan) {
Task.Run(async () => {
await TCPSocketUtils.accept_connections_async(ip, port, handler, TimeSpan.FromSeconds(1));
});
diff --git a/src/DataStreamSuite/PubSub/PubSubMessage.cs b/src/DataStreamSuite/PubSub/PubSubMessage.cs
index 722769216..3970f1cf4 100644
--- a/src/DataStreamSuite/PubSub/PubSubMessage.cs
+++ b/src/DataStreamSuite/PubSub/PubSubMessage.cs
@@ -4,31 +4,39 @@ using System.IO;
using BCG;
using BCG.Utilities;
-namespace BCG
-{
- // Tuple of
- public class PubSubMessage
- {
- public PubSubMessage (MetaData metaData, Stream body)
- {this.metaData = metaData; this.body = body;}
+namespace BCG {
+ // PubItems are published to the pubsub wrapped in this class. It contains PubMetaData, wrapped in the MetaData
+ // object and the actualy published payload in the body stream
+ public class PubSubMessage {
+ public PubSubMessage(MetaData metaData, Stream body) { this.meta_data = metaData; this.body = body; }
- public PubSubMessage (MetaData metaData)
- {this.metaData = metaData;}
+ public PubSubMessage(PubMetaData pub_meta_data, Stream body)
+ : this(new MetaData(pub_meta_data), body) { }
- public MetaData metaData;
+ public PubSubMessage(MetaData metaData) { this.meta_data = metaData; }
+
+ public MetaData meta_data;
public Stream body = new MemoryStream(0);
- public Stream toStream()
- {
+ public Stream to_stream() {
MemoryStream ms = new MemoryStream();
- metaData.save(ms);
- if (body.Length == 0 || body.Length == body.Position)
+ meta_data.save(ms);
+ if (body.Length == 0 || body.Length == body.Position) {
+ bts.Log.Gen.error("Error: Trying to publishing message with no content.");
Console.WriteLine("Error: Trying to publishing message with no content.");
+ }
StreamUtilityMethods.copyTo(new Stream[] { body }, ms);
-
ms.Position = 0;
return ms;
}
+ public byte[] to_bytes() {
+ return StreamUtilityMethods.getBytesFromStream(to_stream());
+ }
+
+ public override string ToString() {
+ return meta_data.ToString();
+ }
+
}
}
diff --git a/src/DataStreamSuite/PubSub/PubSubUpdate.cs b/src/DataStreamSuite/PubSub/PubSubUpdate.cs
index be922b6e6..8f987cff3 100644
--- a/src/DataStreamSuite/PubSub/PubSubUpdate.cs
+++ b/src/DataStreamSuite/PubSub/PubSubUpdate.cs
@@ -2,22 +2,21 @@ using System;
using System.Collections;
using System.IO;
-namespace BCG
-{
+namespace BCG {
///
/// this is the data returned from the
/// pubsub server
///
- public class PubSubUpdate
- {
-
- public PubSubUpdate(string tag, string tagType, Stream body)
- { this.tag = tag; this.body = body; this.tagType = tagType; }
+ public class PubSubUpdate {
+
+ public PubSubUpdate(string tag, string tagType, Stream body) { this.tag = tag; this.body = body; this.tagType = tagType; }
public string tag;
public Stream body;
public string tagType;
-
+ public override string ToString() {
+ return $"PubSubUpdate tag: {tag} tag_type: {tagType} len: {body.Position}";
+ }
};
}
diff --git a/src/DataStreamSuite/PubSub/Server/Communication/ManagedTCP/ManagedTCPMessageHub.cs b/src/DataStreamSuite/PubSub/Server/Communication/ManagedTCP/ManagedTCPMessageHub.cs
index df6d6146d..f77daf791 100644
--- a/src/DataStreamSuite/PubSub/Server/Communication/ManagedTCP/ManagedTCPMessageHub.cs
+++ b/src/DataStreamSuite/PubSub/Server/Communication/ManagedTCP/ManagedTCPMessageHub.cs
@@ -9,17 +9,14 @@ using System.IO;
using System.Diagnostics;
using mbts;
-namespace BCG
-{
+namespace BCG {
public class ManagedTCPMessageHub : IPubsubMessageHub,
ITCPConnectionHandler,
- ITCPMessageHandler
- {
+ ITCPMessageHandler {
private int myPort;
private bool myIsDisposed = false;
- public int port
- {
+ public int port {
get { return myPort; }
//property is read only
@@ -66,8 +63,7 @@ namespace BCG
private DateTime myLastHeartbeatDeadCollectionTime = DateTime.Now;
private DateTime myLastDisposedDeadCollectionTime = DateTime.Now;
- public ManagedTCPMessageHub(int port, TimeSpan hbSendInterval, int missingHBsForGC, TimeSpan collectDisposedConnectionsPeriod)
- {
+ public ManagedTCPMessageHub(int port, TimeSpan hbSendInterval, int missingHBsForGC, TimeSpan collectDisposedConnectionsPeriod) {
myPort = port;
myHeartbeatSendInterval = hbSendInterval;
mySubscriberDropThreshold = new TimeSpan(0, 0, 0, 0, Convert.ToInt32(hbSendInterval.TotalMilliseconds * missingHBsForGC));
@@ -81,24 +77,21 @@ namespace BCG
#region IPubsubMessageHub Members
- public void registerDataCallback(DataDelegate del)
- {
+ public void registerDataCallback(DataDelegate del) {
// BlueEventLog.logAssert(!myActivated, "connection callbacks should be registered before the call to activate");
myDataCb = del;
}
- public void registerConnectionCallback(ConnectionStatusChange del)
- {
+ public void registerConnectionCallback(ConnectionStatusChange del) {
//BlueEventLog.logAssert(!myActivated, "data callbacks should be registered before the call to activate");
myConnCb = del;
}
- public void activate()
- {
+ public void activate() {
if (PubSub3Config.instance.PS3_BindToRandomPort || myPort == 0)
myPort = ServerToClientManagedTCPConnectionAcceptor.activateWithRandomPort(this, myHeartbeatSendInterval);
else
- myPort = ServerToClientManagedTCPConnectionAcceptor.activate(this, myPort, myHeartbeatSendInterval);
+ myPort = ServerToClientManagedTCPConnectionAcceptor.accept_connections(this, myPort, myHeartbeatSendInterval);
string msg = String.Format("TCP Component is ready, listening on port {0} for incoming connections", myPort);
Console.WriteLine(msg);
@@ -108,19 +101,16 @@ namespace BCG
doItAllThread.Start();
}
- public List> getUpdates(TimeSpan timeout, int maxElements)
- {
+ public List> getUpdates(TimeSpan timeout, int maxElements) {
return myReceivedData.dequeueMultipleElements(timeout, maxElements);
}
- public bool send(string receiver, byte[] data)
- {
+ public bool send(string receiver, byte[] data) {
mySendData.enqueue(new Pair(receiver, data));
return true;
}
- public bool send(string receiver, System.IO.Stream str)
- {
+ public bool send(string receiver, System.IO.Stream str) {
BinaryReader br = new BinaryReader(str);
return send(receiver, br.ReadBytes(Convert.ToInt32(str.Length - str.Position)));
}
@@ -133,17 +123,13 @@ namespace BCG
/// Reports back connected and disconnected connections
/// via the ConnectionStatucChange callback
///
- public void doWork()
- {
- if (myConnCb != null)
- {
- foreach (string nc in myNewConnectionURLs.dequeueAll())
- {
+ public void doWork() {
+ if (myConnCb != null) {
+ foreach (string nc in myNewConnectionURLs.dequeueAll()) {
//BlueEventLog.logEvent(String.Format("doWork : New client {0} connected, making connection callback", nc), PS3LogLevels.connection);
myConnCb(nc, true);
}
- foreach (string dc in myDeadConnectionURLs.dequeueAll())
- {
+ foreach (string dc in myDeadConnectionURLs.dequeueAll()) {
//BlueEventLog.logEvent(String.Format("doWork : Client {0} disconnected, making disconnection callback", dc), PS3LogLevels.disconnection);
myConnCb(dc, false);
}
@@ -160,8 +146,7 @@ namespace BCG
/// stored in the hashtable and used for later communication)
///
///
- public void onConnection(ITCPConnection connection)
- {
+ public void onConnection(ITCPConnection connection) {
myNewConnections.enqueue(connection);
}
@@ -169,48 +154,38 @@ namespace BCG
#region ITCPMessageHandler Members
- public void onData(RemoteMessage message)
- {
+ public void onData(RemoteMessage message) {
Console.WriteLine("ManagedTCPMessgageHub.onData recv msg :" + message.remoteConnectionInfo.ToString());
string sender = new BlutoSubAddress(message.remoteConnectionInfo.ip, message.remoteConnectionInfo.port).ToString();
- if (message.messageType == RemoteMessageType.data)
- {
+ if (message.messageType == RemoteMessageType.Data) {
if (myDataCb != null)
myDataCb(sender, message.message);
else
myReceivedData.enqueue(new Pair(sender, message.message));
- }
- else if (message.messageType == RemoteMessageType.heartbeat)
+ } else if (message.messageType == RemoteMessageType.Heartbeat)
myReceivedHeartbeats.enqueue(sender);
- else
- {
+ else {
//BlueEventLog.logEvent("Unknown message type from the client", BlueEventLevel.Error);
}
}
#endregion
- class TimmingInfo
- {
- public TimmingInfo()
- {
+ class TimmingInfo {
+ public TimmingInfo() {
myTimer = new Stopwatch();
reset();
}
- public void start()
- {
- if (PubSub3Config.instance.PS3_DoItAllSecondsBetweenLogs > 0)
- {
+ public void start() {
+ if (PubSub3Config.instance.PS3_DoItAllSecondsBetweenLogs > 0) {
myTimer.Reset();
myTimer.Start();
}
}
- public void stop()
- {
- if (PubSub3Config.instance.PS3_DoItAllSecondsBetweenLogs > 0)
- {
+ public void stop() {
+ if (PubSub3Config.instance.PS3_DoItAllSecondsBetweenLogs > 0) {
myTimer.Stop();
myMin = Math.Min(myMin, myTimer.ElapsedMilliseconds);
myMax = Math.Max(myMax, myTimer.ElapsedMilliseconds);
@@ -219,16 +194,14 @@ namespace BCG
}
}
- public void reset()
- {
+ public void reset() {
myMin = Double.MaxValue;
myMax = Double.MinValue;
myTotal = 0;
myNMeasurements = 0;
}
- public override string ToString()
- {
+ public override string ToString() {
if (myNMeasurements > 0)
return String.Format("min={0} max={1} avg={2} nMeasurements={3}", myMin, myMax, myTotal / myNMeasurements, myNMeasurements);
else
@@ -242,8 +215,7 @@ namespace BCG
private double myTotal;
}
- private void myDoItAll()
- {
+ private void myDoItAll() {
Dictionary times = new Dictionary();
times.Add("myHandleNewConnections", new TimmingInfo());
times.Add("myCollectDisposedConnections", new TimmingInfo());
@@ -252,12 +224,9 @@ namespace BCG
DateTime lastTimmingLog = DateTime.Now;
- while (true)
- {
- try
- {
- while (true)
- {
+ while (true) {
+ try {
+ while (true) {
///new connections
times["myHandleNewConnections"].start();
myHandleNewConnections();
@@ -279,16 +248,12 @@ namespace BCG
Pair p = mySendData.dequeue(myReadSendQueueTimeout);
times["send"].start();
- if (p != null)
- {
+ if (p != null) {
ITCPConnection conn;
myConnections.TryGetValue(p.first, out conn);
- if (conn != null)
- {
+ if (conn != null) {
conn.send(p.second);
- }
- else
- {
+ } else {
string warningMsg = String.Format("sending data to {0} failed, this client might have " +
"disconnected, in which case it will be garbage collected within 60 secs", p.first);
//BlueEventLog.logEvent(warningMsg, PS3LogLevels.disconnection);
@@ -297,25 +262,21 @@ namespace BCG
times["send"].stop();
if (PubSub3Config.instance.PS3_DoItAllSecondsBetweenLogs > 0 &&
- (DateTime.Now - lastTimmingLog).TotalSeconds > PubSub3Config.instance.PS3_DoItAllSecondsBetweenLogs)
- {
+ (DateTime.Now - lastTimmingLog).TotalSeconds > PubSub3Config.instance.PS3_DoItAllSecondsBetweenLogs) {
lastTimmingLog = DateTime.Now;
StringBuilder b = new StringBuilder();
b.AppendFormat("myDoItAll stats:\n");
b.AppendFormat("queue size: {0}\n", mySendData.getCount());
- foreach (string timerName in times.Keys)
- {
+ foreach (string timerName in times.Keys) {
b.AppendFormat("{0}: {1}\n", timerName, times[timerName]);
times[timerName].reset();
}
//BlueEventLog.logEvent(b.ToString(), PS3LogLevels.performance);
}
}
- }
- catch (Exception ex)
- {
+ } catch (Exception ex) {
//BlueEventLog.logEvent(ex);
if (ex is OutOfMemoryException)
throw ex;
@@ -323,19 +284,15 @@ namespace BCG
}
}
- private void myCollectDisposedConnections()
- {
- if (DateTime.Now - myLastDisposedDeadCollectionTime > myCollectDisposedConnectionsPeriod)
- {
+ private void myCollectDisposedConnections() {
+ if (DateTime.Now - myLastDisposedDeadCollectionTime > myCollectDisposedConnectionsPeriod) {
myLastDisposedDeadCollectionTime = DateTime.Now;
List disposedURLs = new List();
- foreach (KeyValuePair p in myConnections)
- {
+ foreach (KeyValuePair p in myConnections) {
if (p.Value.isDisposed)
disposedURLs.Add(p.Key);
}
- foreach (string url in disposedURLs)
- {
+ foreach (string url in disposedURLs) {
string disposeMsg = String.Format("Collecting disposed connections : {0} is disposed by the connection itself, " +
"connection count before deleting this = {1}", url, myConnections.Count);
Console.WriteLine(disposeMsg);
@@ -346,10 +303,8 @@ namespace BCG
}
}
- private void myCollectMissingHeartbeatConnections()
- {
- if (DateTime.Now - myLastHeartbeatDeadCollectionTime > mySubscriberDropThreshold)
- {
+ private void myCollectMissingHeartbeatConnections() {
+ if (DateTime.Now - myLastHeartbeatDeadCollectionTime > mySubscriberDropThreshold) {
myLastHeartbeatDeadCollectionTime = DateTime.Now;
///these are all the hbs received bw the last
///and current collectDeadConnection calls
@@ -365,10 +320,9 @@ namespace BCG
foreach (string clientURL in myConnections.Keys)
if (!indexedHbs.ContainsKey(clientURL))
deadClients.Add(clientURL);
- foreach (string deadClient in deadClients)
- {
+ foreach (string deadClient in deadClients) {
string disposeMsg = String.Format("Collecting missing HB connections : {0} is dead due to missing hbs, Disposing it now, " +
- "connection count before deleting this = {1}", deadClient, myConnections.Count);
+ "connection count before deleting this = {1}", deadClient, myConnections.Count);
//BlueEventLog.logEvent(disposeMsg, PS3LogLevels.disconnection);
Console.WriteLine(disposeMsg);
myConnections[deadClient].Dispose();
@@ -378,11 +332,9 @@ namespace BCG
}
}
- private void myHandleNewConnections()
- {
+ private void myHandleNewConnections() {
IList newConns = myNewConnections.dequeueAll();
- foreach (ITCPConnection conn in newConns)
- {
+ foreach (ITCPConnection conn in newConns) {
string ip;
int port;
conn.getPeerAddress(out ip, out port);
@@ -399,13 +351,11 @@ namespace BCG
}
#region IDisposable Memebers
- public void Dispose()
- {
+ public void Dispose() {
myIsDisposed = true;
}
- public bool isDisposed
- {
+ public bool isDisposed {
get { return myIsDisposed; }
}
#endregion
diff --git a/src/DataStreamSuite/PubSub/Server/InternalTagHandling/SystemHeartbeatPublisher.cs b/src/DataStreamSuite/PubSub/Server/InternalTagHandling/SystemHeartbeatPublisher.cs
index af25d1432..1aa3b3591 100644
--- a/src/DataStreamSuite/PubSub/Server/InternalTagHandling/SystemHeartbeatPublisher.cs
+++ b/src/DataStreamSuite/PubSub/Server/InternalTagHandling/SystemHeartbeatPublisher.cs
@@ -4,23 +4,20 @@ using System.Text;
using BCG.Utilities.General;
using System.IO;
-namespace BCG
-{
+namespace BCG {
///
/// Periodicaly publishes a heartbeat, under the tag name System_Heartbeat.
/// A subscriber can subscribe to it, and find out of a PubSub is alive or
/// not. Infact more so, if the subsriptions are working or not.
///
- internal class SystemHeartbeatPublisher : IWorker
- {
+ internal class SystemHeartbeatPublisher : IWorker {
public static string tagType = "System_Heartbeat";
public static string tagName = "System_Heartbeat";
-
+
private static SystemHeartbeatPublisher mySelf;
- private SystemHeartbeatPublisher ()
- {
-
+ private SystemHeartbeatPublisher() {
+
///this is using a multithreaded MasterWorker since the
///regular one is called within the MessageReactor, which
///waits 2500 msecs before calling doWork. This 2500 msecs
@@ -29,16 +26,14 @@ namespace BCG
MasterWorker.getInstance(true).addWorker(this, new TimeSpan(0, 0, 0, 0, 500));
}
- public static void init()
- {
+ public static void init() {
if (mySelf == null)
mySelf = new SystemHeartbeatPublisher();
}
#region IWorker Members
- public void doWork()
- {
+ public void doWork() {
PubMetaData pub = new PubMetaData(tagType, tagName, 1, "local", ClientInfo.thisClient.processString);
MetaData md = new MetaData(pub);
MemoryStream ms = new MemoryStream();
diff --git a/src/DataStreamSuite/PubSub/Server/PubSubMessageReactor.cs b/src/DataStreamSuite/PubSub/Server/PubSubMessageReactor.cs
index 35ef25355..7bf3dd9e2 100644
--- a/src/DataStreamSuite/PubSub/Server/PubSubMessageReactor.cs
+++ b/src/DataStreamSuite/PubSub/Server/PubSubMessageReactor.cs
@@ -16,10 +16,8 @@ using System.Collections.Generic;
using mbts;
using mbts.spark;
-namespace BCG
-{
- public class PubSubMessageReactor
- {
+namespace BCG {
+ public class PubSubMessageReactor {
private ServerMessageHub myMessageHub;
private delegate void MyMsgHandler(string sender, Stream msg, MetaData m);
private Dictionary myOperationToHandler = new Dictionary();
@@ -39,32 +37,24 @@ namespace BCG
/* This delegate allows pubsub components to be notified when the identity of the pubsub is known*/
public delegate void IdentityFoundDelegate(string identity, bool isRoot);
public event IdentityFoundDelegate onIdentityFound;
- public void fireIdentityFound(string identity, bool isRoot)
- {
+ public void fireIdentityFound(string identity, bool isRoot) {
if (onIdentityFound != null)
onIdentityFound(identity, isRoot);
}
- private IPubSubGovernor myGovernor;
-
-
public Dictionary myTagCompressionState = new Dictionary();
public PubSubMessageReactor() : this(false, false, string.Empty, string.Empty) { }
public PubSubMessageReactor(string q) : this(false, false, string.Empty, q) { }
- public PubSubMessageReactor(bool clearQueue, bool bootEvent, string oldIP, string psq)
- {
+ public PubSubMessageReactor(bool clearQueue, bool bootEvent, string oldIP, string psq) {
myOperationToHandler.Add(typeof(PubMetaData).Name, new MyMsgHandler(myHandlePub));
myOperationToHandler.Add(typeof(SubMetaData).Name, new MyMsgHandler(myHandleSub));
myOperationToHandler.Add(typeof(UnSubMetaData).Name, new MyMsgHandler(myHandleUnsub));
myOperationToHandler.Add(typeof(TransactionMetaData).Name, new MyMsgHandler(myHandleTransaction));
- // TODO, governor needs to be removed since its subststaion retired code
- // if (PubSub3Config.instance.PS3_Components.governor != null)
- // myGovernor = PubSubComponentFactory.buildGovernor(this);
- //BlueEventLog.logEvent("System Initialized", PS3LogLevels.info);
+ bts.Log.Gen.info("PubSubMessageReactor.cons System Initialized");
myReceivingProcThread = new Thread(new ThreadStart(myReceivingThreadProc));
myMessageHub = ServerMessageHub.instance;
@@ -75,93 +65,52 @@ namespace BCG
#region message handlers
- public PubSubState state
- {
+ public PubSubState state {
get { return myState; }
//this variable is read only
}
- private void myHandlePub(string sender, Stream msg, MetaData m)
- {
-
+ private void myHandlePub(string sender, Stream msg_str, MetaData meta_data) {
+ bts.Log.Gen.info($"PubSubMessageReactor.myHandlePub sender: {sender} metadata: {meta_data} str.pos: {msg_str.Position} str.len: {msg_str.Length}");
mySingleTagTimeSliceTimer.start();
///the position in the stream is set to where the data starts with,
///since the meta data was already read in the myProcessMsg
PubMetaData pub = new PubMetaData();
- m.copyTo(pub);
+ meta_data.copyTo(pub);
pub.connection = sender;
- Console.WriteLine("PubSubMessageReactor.myHandlePub sender: " + sender + " tag: " + pub.tag);
-
- //check to see if this publish took a while to get here
pub.warnIfLatencyExceedsThreshold();
+ var subs_for_tag = myState.getSubscriberConnectionsForTag(pub.tag);
+ bts.Log.Gen.info($"PubSubMessageReactor.myHandlePub {subs_for_tag.Count} subs for tag: {pub.tag}");
- //check the governor to see if this publish is allowed, if we have a governor
- PubSubGovernorResponse response = PubSubGovernorResponse.Accepted;
- if (myGovernor != null)
- response = myGovernor.requestToPublish(pub, msg);
-
- if (response != PubSubGovernorResponse.Accepted)
- {
- // BlueEventLog2.instance().logEvent(string.Concat("PubSub Governor ",
- // myGovernor.GetType().Name,
- // " returned response ",
- // response.ToString(),
- // " publish on tag",
- // pub.tag,
- // "was ignored."), BlueEventLog2Level.Warning);
- return;
- }
-
-
- //report the fact that we have a publish on this tag, if it's a debug tag
- if (PubSub3Config.instance.isTagDebugTag(pub.tag))
- {
- // BlueEventLog.logEvent(string.Concat(GetType().Name,
- // " got publish on tag ",
- // pub.tag,
- // " from app ", pub.publishingApp,
- // " over connection ",
- // pub.connection, ".\n",
- // pub.isCompressed ? "Data was compressed.\n" : "Data was not compresed.\n",
- // "total size: ",
- // pub.size),
-
- // PS3LogLevels.debug);
-
-
- }
///for all the subscribers, sends the messages over straightaway
- foreach (string address in myState.getSubscriberConnectionsForTag(pub.tag))
- {
+ foreach (string address in myState.getSubscriberConnectionsForTag(pub.tag)) {
///the position is adjusted to zero, so as to include
///the meta data as part of the message
- msg.Position = 0;
- myMessageHub.send(address, msg);
+ msg_str.Position = 0;
+ bts.Log.Gen.info($"PubSubMessageReactor.myHandlePub sending tag: {pub.tag} to {address} len: {msg_str.Length - msg_str.Position}");
+ myMessageHub.send(address, msg_str);
}
//reset the position of the message so we can decompress it appropriately
- msg.Position = 0;
- msg.Position = m.size();
+ msg_str.Position = 0;
+ msg_str.Position = meta_data.size();
- if (pub.isCompressed)
- {
- long mdLength = msg.Position;
- long compressedSize = msg.Length - mdLength;
- if (compressedSize == 0)
- {
+ if (pub.isCompressed) {
+ long mdLength = msg_str.Position;
+ long compressedSize = msg_str.Length - mdLength;
+ if (compressedSize == 0) {
string errorMsg = "Error: tag " + pub.tag + " had compressed size of 0 bytes. This shouldnt' happen. Not decompressing tag or sending out update.";
//BlueEventLog.logEvent(errorMsg, BlueEventLevel.Error);
return;
}
- msg = StreamDecompressor.decompressStream(msg);
- long decompressedSize = msg.Length - mdLength;
+ msg_str = StreamDecompressor.decompressStream(msg_str);
+ long decompressedSize = msg_str.Length - mdLength;
- if (decompressedSize != pub.decompressedSize || compressedSize != pub.size)
- {
+ if (decompressedSize != pub.decompressedSize || compressedSize != pub.size) {
string compressionWarning = string.Format("Warning: Stream for tag {0} decompressed from {1} to {2} bytes, with {3} byes of metadata. Metadata expected {4} to {5}. Tag state not updated.",
pub.tag,
compressedSize,
@@ -169,40 +118,31 @@ namespace BCG
mdLength,
pub.size,
pub.decompressedSize);
-
- //BlueEventLog.logEvent(compressionWarning, BlueEventLevel.Error);
+ bts.Log.Gen.warn(compressionWarning);
return;
-
}
-
}
//give the user a notification of the compression status of the tag has changed.
if ((!(myTagCompressionState.ContainsKey(pub.tag)) ||
- myTagCompressionState[pub.tag] != pub.isCompressed))
- {
+ myTagCompressionState[pub.tag] != pub.isCompressed)) {
string compressionMessage;
myTagCompressionState[pub.tag] = pub.isCompressed;
- if (pub.isCompressed)
- {
+ if (pub.isCompressed) {
compressionMessage = "Tag " + pub.tag + " is compressed.";
//BlueEventLog.logEvent(compressionMessage, PS3LogLevels.compressionRatio);
- }
- else
- {
+ } else {
compressionMessage = "Tag " + pub.tag + " is not compressed.";
//BlueEventLog.logEvent(compressionMessage, PS3LogLevels.compressionRatio);
-
}
-
}
///updating state
- msg.Position = 0;
- msg.Position += m.size();
- myState.updatePubData(pub, msg);
+ msg_str.Position = 0;
+ msg_str.Position += meta_data.size();
+ myState.updatePubData(pub, msg_str);
mySingleTagTimeSliceTimer.stop();
@@ -213,8 +153,8 @@ namespace BCG
}
- private void myHandleSub(string sender, Stream msg, MetaData m)
- {
+ private void myHandleSub(string sender, Stream msg, MetaData m) {
+ bts.Log.Gen.info($"PubSubMessageReactor.myHandleSub sender: {sender} metadata: {m} str.pos: {msg.Position} str.len: {msg.Length}");
SubMetaData sub = new SubMetaData();
m.copyTo(sub);
sub.connection = sender;
@@ -222,12 +162,10 @@ namespace BCG
///update the state
myState.sub(sub);
///to all these new subscriber s, send the existing data
- foreach (string tag in sub.tags)
- {
+ foreach (string tag in sub.tags) {
byte[] data = myState.getContent(tag);
//ie data has been published once
- if (data != null)
- {
+ if (data != null) {
string tagType = myState.getTagType(tag);
///passing "" as the 4th arg, as PubMeta is used both by the
///publisher to publish data to the server (where the publisher
@@ -237,17 +175,14 @@ namespace BCG
///needed as of now, so its left black to save a few bytes
PubMetaData pub;
MemoryStream realContent;
- if (PubSub3Config.instance.isTagCompressed(tag))
- {
+ if (PubSub3Config.instance.isTagCompressed(tag)) {
SharpZipCompressor Kompessor = new SharpZipCompressor();
realContent = new MemoryStream();
Kompessor.compress(new MemoryStream(data), realContent);
pub = new PubMetaData(tagType, tag, (int)realContent.Length, (int)data.Length, "", "");
- }
- else
- {
+ } else {
realContent = new MemoryStream(data);
pub = new PubMetaData(tagType, tag, data.Length, "", "");
}
@@ -262,8 +197,7 @@ namespace BCG
}
}
- private void myHandleUnsub(string sender, Stream msg, MetaData m)
- {
+ private void myHandleUnsub(string sender, Stream msg, MetaData m) {
UnSubMetaData unsub = new UnSubMetaData();
m.copyTo(unsub);
if (unsub.connection.Trim().Length == 0)
@@ -271,8 +205,7 @@ namespace BCG
myState.unsub(unsub);
}
- private void myHandleTransaction(string sender, Stream msg, MetaData md)
- {
+ private void myHandleTransaction(string sender, Stream msg, MetaData md) {
mySingleTagTimeSliceTimer.start();
TransactionMetaData t = new TransactionMetaData();
md.copyTo(t);
@@ -280,8 +213,7 @@ namespace BCG
///form the structure tag->byte[]*
Dictionary tagToMessages = new Dictionary();
BinaryReader br = new BinaryReader(msg);
- for (int i = 0; i < nMessages; i++)
- {
+ for (int i = 0; i < nMessages; i++) {
MetaData pubMd = new MetaData(msg);
PubMetaData pub = new PubMetaData();
pubMd.copyTo(pub);
@@ -289,8 +221,7 @@ namespace BCG
byte[] tagData = new byte[pub.size];
msg.Read(tagData, 0, tagData.Length);
//report the fact that we have a publish on this tag, if it's a debug tag
- if (PubSub3Config.instance.isTagDebugTag(pub.tag))
- {
+ if (PubSub3Config.instance.isTagDebugTag(pub.tag)) {
// BlueEventLog.logEvent(string.Concat(GetType().Name,
// " got publish on tag ",
// pub.tag,
@@ -315,13 +246,11 @@ namespace BCG
}
///this gives subscriber->tag*
Dictionary> subscriberToTags = myState.getSubscriberConnectionsForTags(tagToMessages.Keys);
- foreach (KeyValuePair> kvp in subscriberToTags)
- {
+ foreach (KeyValuePair> kvp in subscriberToTags) {
MemoryStream subStream = new MemoryStream();
TransactionMetaData subTransaction = new TransactionMetaData(kvp.Value.Count);
new MetaData(subTransaction).save(subStream);
- foreach (string tag in kvp.Value)
- {
+ foreach (string tag in kvp.Value) {
byte[] tagData = tagToMessages[tag];
PubMetaData pub = new PubMetaData(myState.getTagType(tag), tag, tagData.Length, "", "");
new MetaData(pub).save(subStream);
@@ -336,8 +265,7 @@ namespace BCG
double timeExpended = mySingleTagTimeSliceTimer.lastIntervalTime;
//Don't try to divide by zero
int numTags = tagToMessages.Keys.Count;
- if (numTags != 0)
- {
+ if (numTags != 0) {
double timeExpendedPerTag = timeExpended / tagToMessages.Keys.Count;
if (onSingleTagPub != null)
foreach (string tag in tagToMessages.Keys)
@@ -351,18 +279,16 @@ namespace BCG
///
///
///
- private void myProcessMsg(string sender, Stream msg, out MetaData md)
- {
- md = new MetaData(msg);
+ private void myProcessMsg(string sender, Stream msg, out MetaData md) {
+ md = new MetaData(msg); // msg's Posiiton moved to end of meta data
MyMsgHandler op = myOperationToHandler[md["op-code"]];
- //BlueEventLog.logEvent(string.Format("process message {0}", m));
+ bts.Log.Gen.info($"PubSubMessageReactor.myProcessMsg sender: {sender} metadata: {md}");
op(sender, msg, md);
}
#endregion
- private void myHandleConnections(string client, bool connected)
- {
+ private void myHandleConnections(string client, bool connected) {
Console.WriteLine("PubSubMessageReactor.myHandleConnections client: " + client + " connected: " + connected);
///interested in disconnections only, as connections of no
///significance until they subscribe, in which case an entry
@@ -371,13 +297,11 @@ namespace BCG
myState.removeConnection(client);
}
- public void stop()
- {
+ public void stop() {
myStop = true;
}
- public void start()
- {
+ public void start() {
myReceivingProcThread.Start();
}
@@ -385,8 +309,7 @@ namespace BCG
/// loops around and reads messages from the messageReceiver. calls processMsg
/// passing in the IClientMessage. also logs stuff about the message.
///
- private void myReceivingThreadProc()
- {
+ private void myReceivingThreadProc() {
TimeSpan receiveTimeout = new TimeSpan(0, 0, 0, 0, 2500);
myMessageHub.activate();
@@ -398,31 +321,25 @@ namespace BCG
string sender;
Stream msg;
MetaData meta;
- while (!myStop)
- {
+ while (!myStop) {
sender = null;
msg = null;
meta = null;
- try
- {
+ try {
List> receivedData = myMessageHub.getUpdates(receiveTimeout, 1);
- if (receivedData.Count > 0)
- {
+ if (receivedData.Count > 0) {
sender = receivedData[0].first;
msg = new MemoryStream(receivedData[0].second);
myTimer.start();
myProcessMsg(sender, msg, out meta);
myTimer.stop();
- if (myTimer.lastIntervalTime > myProcessingWarningThreshold)
- {
+ if (myTimer.lastIntervalTime > myProcessingWarningThreshold) {
string warningMsg = String.Format("processing metadata {0} took {1} msecs", meta, myTimer.lastIntervalTime);
//BlueEventLog.logEvent(warningMsg, PS3LogLevels.performance);
}
}
myMasterWorker.doWork();
- }
- catch (Exception e)
- {
+ } catch (Exception e) {
//BlueEventLog.logEvent(e, BlueEventLevel.Error);
Console.WriteLine("{0} : exception handling message: {1}\n", DateTime.Now, e.Message);
string errMsg = String.Format("Following information about the meta data and sender is available : " +
diff --git a/src/DataStreamSuite/PubSub/Server/PubSubState.cs b/src/DataStreamSuite/PubSub/Server/PubSubState.cs
index 8b600b932..a30f16aac 100644
--- a/src/DataStreamSuite/PubSub/Server/PubSubState.cs
+++ b/src/DataStreamSuite/PubSub/Server/PubSubState.cs
@@ -7,21 +7,19 @@ using System.IO;
using mbts;
-namespace BCG
-{
+namespace BCG {
///
/// Mantains all the state that there is in the server.
/// This information is keyed off the tags (rather than
/// keyed off subscribers or publishers)
- /// State information consists of 2 distints sets :
+ /// State information consists of 2 distinct sets :
/// myTagToData consists of all the data published to
/// this pubsub.
/// myTagToTagInfo consists of all the subscription and
/// publishing information
///
///
- public class PubSubState
- {
+ public class PubSubState {
public delegate void PubSubStateSingleTagChangeDelegate(PubSubSingleTagStateEvent theEvent);
public event PubSubStateSingleTagChangeDelegate onSingleTagChange;
@@ -33,8 +31,7 @@ namespace BCG
private Dictionary myTagToData = new Dictionary();
private Dictionary myTagToPubsubMap = new Dictionary();
- public PubSubState()
- {
+ public PubSubState() {
SystemSubscriptionMapPublisher.init(this);
SystemStatsPublisher.init(this);
SystemHeartbeatPublisher.init();
@@ -49,13 +46,10 @@ namespace BCG
///
///
///
- public void sub(SubMetaData sub)
- {
+ public void sub(SubMetaData sub) {
///tag based key ds update
- foreach (string tag in sub.tags)
- {
- if (!myTagToPubsubMap.ContainsKey(tag))
- {
+ foreach (string tag in sub.tags) {
+ if (!myTagToPubsubMap.ContainsKey(tag)) {
myTagToPubsubMap.Add(tag, new SingleTagPubSubMap(tag));
}
myTagToPubsubMap[tag].onSub(sub);
@@ -67,20 +61,15 @@ namespace BCG
onTagMapChanged(sub.tags);
}
- public void unsub(UnSubMetaData unsub)
- {
- foreach (string tag in unsub.tags)
- {
- if (myTagToPubsubMap.ContainsKey(tag))
- {
+ public void unsub(UnSubMetaData unsub) {
+ foreach (string tag in unsub.tags) {
+ if (myTagToPubsubMap.ContainsKey(tag)) {
///maybe check here, that if there are no subscribers
///and publishers for the tag then remove it.
myTagToPubsubMap[tag].onUnsub(unsub);
if (onSingleTagChange != null)
onSingleTagChange(new PubSubSingleTagStateEvent(tag, PubSubSingleTagStateEvent.EventType.unsubscription, unsub.connection, unsub.unsubscribingApp));
- }
- else
- {
+ } else {
string warningMsg = String.Format("{0} was never published or subscribed on this pubsub, hence" +
" the unsub call by app {1} is voided", tag, unsub.unsubscribingApp);
//BlueEventLog.logEvent(warningMsg, BlueEventLevel.Warning);
@@ -90,11 +79,9 @@ namespace BCG
onTagMapChanged(unsub.tags);
}
- public void removeConnection(string connection)
- {
+ public void removeConnection(string connection) {
List tagsEffected = new List();
- foreach (KeyValuePair p in myTagToPubsubMap)
- {
+ foreach (KeyValuePair p in myTagToPubsubMap) {
///maybe check here, that if there are no subscribers
///and publishers for the tag then remove it.
bool wasPublisher = false;
@@ -103,8 +90,7 @@ namespace BCG
if (p.Value.onConnectionRemoveIfExists(connection, out wasPublisher, out wasSubscriber))
tagsEffected.Add(tag);
- if (onSingleTagChange != null)
- {
+ if (onSingleTagChange != null) {
//we don't know the app or key qualifier or anything for these connection. that is unfortunate.
if (wasPublisher)
onSingleTagChange(new PubSubSingleTagStateEvent(tag, PubSubSingleTagStateEvent.EventType.publisherDie, connection, ""));
@@ -128,67 +114,60 @@ namespace BCG
///
///
///
- public void updatePubData(PubMetaData pub, Stream msg)
- {
+ public void updatePubData(PubMetaData pub, Stream msg) {
+
int sz = (int)(msg.Length - msg.Position);
///this is the only place where SingleTagData should be created
- if (!myTagToData.ContainsKey(pub.tag))
- {
+ if (!myTagToData.ContainsKey(pub.tag)) {
///first time data is published for this tag
myTagToData.Add(pub.tag, new SingleTagData(pub.tag, pub.type));
}
myTagToData[pub.tag].pubUpdate(msg);
- if (!myTagToPubsubMap.ContainsKey(pub.tag))
- {
+ if (!myTagToPubsubMap.ContainsKey(pub.tag)) {
myTagToPubsubMap.Add(pub.tag, new SingleTagPubSubMap(pub.tag));
}
bool pubChanged = false;
myTagToPubsubMap[pub.tag].onPub(pub, out pubChanged);
- if (pubChanged)
- {
+ if (pubChanged) {
if (onTagMapChanged != null)
onTagMapChanged(new string[] { pub.tag });
if (onSingleTagChange != null)
onSingleTagChange(
- new PubSubSingleTagStateEvent(pub.tag,
- PubSubSingleTagStateEvent.EventType.publish,
+ new PubSubSingleTagStateEvent(pub.tag,
+ PubSubSingleTagStateEvent.EventType.publish,
pub.connection, pub.publishingApp));
}
if (onPublishStats != null)
onPublishStats(pub.tag, sz);
-
+
}
#endregion
- public ICollection getSubscriberConnectionsForTag(string tag)
- {
+ public ICollection getSubscriberConnectionsForTag(string tag) {
if (myTagToPubsubMap.ContainsKey(tag))
return myTagToPubsubMap[tag].subscriberConnections;
else
return new string[] { };
}
- public ICollection getSubscribingAppsForTag(string tag)
- {
+ public ICollection getSubscribingAppsForTag(string tag) {
if (myTagToPubsubMap.ContainsKey(tag))
return myTagToPubsubMap[tag].subscripingApps;
else
return new string[] { };
}
- public byte[] getContent(string tag)
- {
+ public byte[] getContent(string tag) {
if (!myTagToData.ContainsKey(tag))
return null;
else
return myTagToData[tag].getCurrentContent();
}
- public string getTagType(string tag)
- {
+ public string getTagType(string tag) {
if (!myTagToData.ContainsKey(tag))
return null;
else
@@ -207,29 +186,23 @@ namespace BCG
///
public void getAllConnections(string tag, out Dictionary subscribers,
out Dictionary activePublishers,
- out ICollection> deadPublishers)
- {
- if (myTagToPubsubMap.ContainsKey(tag))
- {
+ out ICollection> deadPublishers) {
+ if (myTagToPubsubMap.ContainsKey(tag)) {
SingleTagPubSubMap map = myTagToPubsubMap[tag];
subscribers = map.subscribers;
activePublishers = map.activePublishers;
deadPublishers = map.deadPublishers;
- }
- else
- {
+ } else {
subscribers = activePublishers = new Dictionary();
deadPublishers = new List>();
}
}
- public ICollection allTags
- {
+ public ICollection allTags {
get { return myTagToPubsubMap.Keys; }
}
- public ICollection tagsWithData
- {
+ public ICollection tagsWithData {
get { return myTagToData.Keys; }
}
@@ -239,15 +212,11 @@ namespace BCG
///
///
///
- public Dictionary> getSubscriberConnectionsForTags(IEnumerable tags)
- {
+ public Dictionary> getSubscriberConnectionsForTags(IEnumerable tags) {
Dictionary> retVal = new Dictionary>();
- foreach (string tag in tags)
- {
- if (myTagToPubsubMap.ContainsKey(tag))
- {
- foreach (string sub in myTagToPubsubMap[tag].subscriberConnections)
- {
+ foreach (string tag in tags) {
+ if (myTagToPubsubMap.ContainsKey(tag)) {
+ foreach (string sub in myTagToPubsubMap[tag].subscriberConnections) {
if (!retVal.ContainsKey(sub))
retVal.Add(sub, new List());
retVal[sub].Add(tag);
diff --git a/src/DataStreamSuite/PubSub/Server/SingleTagData.cs b/src/DataStreamSuite/PubSub/Server/SingleTagData.cs
index 12eb85c70..5edf54946 100644
--- a/src/DataStreamSuite/PubSub/Server/SingleTagData.cs
+++ b/src/DataStreamSuite/PubSub/Server/SingleTagData.cs
@@ -7,21 +7,18 @@ using System.Collections.Generic;
using BCG.Utilities;
using mbts;
-namespace BCG
-{
+namespace BCG {
///
/// SingleTagData consists of (as the name implies)
/// the data published for a tag
///
- internal class SingleTagData
- {
+ internal class SingleTagData {
private string myTagType = null;
private string myTag;
private byte[] myLastPublishedMsg;
private IPubSubServerTagHandler myHandler;
- public SingleTagData(string tag, string tagType)
- {
+ public SingleTagData(string tag, string tagType) {
myTag = tag;
myTagType = tagType;
if (myTagType == SystemSubscriptionMapPublisher.tagType)
@@ -38,16 +35,12 @@ namespace BCG
public string tagType { get { return myTagType; } }
- internal void pubUpdate(Stream stream)
- {
- if (myHandler != null)
- {
- try
- {
+ internal void pubUpdate(Stream stream) {
+ bts.Log.Gen.info($"SingleTagData.pubUpdate tag: {myTag} handler: {myHandler} stream len: {stream.Length - stream.Position}");
+ if (myHandler != null) {
+ try {
myHandler.update(myTag, new Stream[] { stream });
- }
- catch (Exception e)
- {
+ } catch (Exception e) {
// BlueEventLog.logEvent(e);
string errMsg = "tag handler threw an exception " + e.Message + " for tag type = " + myTagType +
" tag = " + myTag + " length = " + stream.Length + "\n" +
@@ -58,30 +51,22 @@ namespace BCG
else
throw new ApplicationException(errMsg, e);
}
- }
- else
- {
+ } else {
myLastPublishedMsg = new byte[stream.Length - stream.Position];
stream.Read(myLastPublishedMsg, 0, myLastPublishedMsg.Length);
}
}
- public byte[] getCurrentContent()
- {
- if (myHandler != null)
- {
+ public byte[] getCurrentContent() {
+ if (myHandler != null) {
return myHandler.getContent(myTag);
- }
- else
- {
+ } else {
return myLastPublishedMsg;
}
}
- private void myHandleHandlerCallbacks(ICollection> cbItems)
- {
- foreach (Triplet p in cbItems)
- {
+ private void myHandleHandlerCallbacks(ICollection> cbItems) {
+ foreach (Triplet p in cbItems) {
string tagName = p.first, tagType = p.second;
byte[] data = p.third;
PubMetaData pub = new PubMetaData(tagType, tagName, data.Length, "local", ClientInfo.thisClient.processString);
diff --git a/src/DataStreamSuite/PubSub/SingleServerSubscriberCore.cs b/src/DataStreamSuite/PubSub/SingleServerSubscriberCore.cs
index 0c1d89d61..0fa8a86f7 100644
--- a/src/DataStreamSuite/PubSub/SingleServerSubscriberCore.cs
+++ b/src/DataStreamSuite/PubSub/SingleServerSubscriberCore.cs
@@ -7,8 +7,7 @@ using BCG.Utilities.General;
using mbts;
using mbts.spark;
-namespace BCG
-{
+namespace BCG {
///
/// Deals with the subscriptions (and getting data) from one
/// pubsub server. Once again, theres no sharing of conenctions
@@ -17,15 +16,13 @@ namespace BCG
/// its concerned with (passed as a conctructor arg).
///
- internal interface ISingleServerSubscriberCore : IDisposable
- {
+ internal interface ISingleServerSubscriberCore : IDisposable {
IList getUpdates(int timeout);
event PubSubConnectionChange onPubSubConnectionChange;
void subscribe(params string[] tags);
void unsubscribe(params string[] tags);
}
- internal class SingleServerSubscriberCore : IDisposable, ISingleServerSubscriberCore
- {
+ internal class SingleServerSubscriberCore : IDisposable, ISingleServerSubscriberCore {
private HighPerformanceTimer myTimer = new HighPerformanceTimer();
private PubSubServerConnectionFactory myConnectionFactory;
private IPubSubServerConnection myConnection;
@@ -33,15 +30,13 @@ namespace BCG
public event PubSubConnectionChange onPubSubConnectionChange;
- public SingleServerSubscriberCore(string serverURL, PubSubServerConnectionFactory connectionFactory)
- {
+ public SingleServerSubscriberCore(string serverURL, PubSubServerConnectionFactory connectionFactory) {
myConnectionFactory = connectionFactory;
myConnection = myConnectionFactory.getConnection(serverURL);
myConnection.registerCallback(new ConnectionStatusChange(myHandleServerReboot));
}
- public IList getUpdates()
- {
+ public IList getUpdates() {
return getUpdates(1);
}
@@ -51,54 +46,41 @@ namespace BCG
///
///
///
- public IList getUpdates(int timeout)
- {
+ public IList getUpdates(int timeout) {
myConnection.doWork();
List retVal = new List();
IList dataItems = myConnection.getUpdates(new TimeSpan(0, 0, 0, 0, timeout), Int32.MaxValue);
- foreach (byte[] data in dataItems)
- {
+ foreach (byte[] data in dataItems) {
processMessage(data, retVal);
}
return retVal;
-
+
}
- public List getSubscribedTags()
- {
+ public List getSubscribedTags() {
return myTags;
}
- public void subscribe(params string[] tags)
- {
- foreach (string tag in tags)
- {
- if (myTags.Contains(tag))
- {
+ public void subscribe(params string[] tags) {
+ foreach (string tag in tags) {
+ if (myTags.Contains(tag)) {
string errMsg = String.Format("tag {0} was already subscribed from server {1}",
tag, myConnection.serverURL);
// BlueEventLog.logEvent(errMsg, BlueEventLevel.Warning);
- }
- else
- {
+ } else {
myTags.Add(tag);
}
}
mySubscribe(tags);
}
- public void unsubscribe(params string[] tags)
- {
+ public void unsubscribe(params string[] tags) {
List unsubTags = new List();
- foreach (string tag in tags)
- {
- if (myTags.Contains(tag))
- {
+ foreach (string tag in tags) {
+ if (myTags.Contains(tag)) {
myTags.Remove(tag);
unsubTags.Add(tag);
- }
- else
- {
+ } else {
string errMsg = String.Format("tag {0} is being unsubscribed from server {1}, eventhough " +
"it was never subscribed", tag, myConnection.serverURL);
// BlueEventLog.logEvent(errMsg, BlueEventLevel.Warning);
@@ -108,13 +90,13 @@ namespace BCG
Stream str = new MemoryStream();
new MetaData(unsub).save(str);
str.Position = 0;
+ // this is where data is actually sent out
myConnection.send(str);
}
#region IDisposable Members
- public void Dispose()
- {
+ public void Dispose() {
///remove the subscriber
//myConnection.send(new PubSubMessage(new MetaData(new RemoveSubscriberMetaData(myConnection.clientURL))).toStream());
myConnection.Dispose();
@@ -126,8 +108,7 @@ namespace BCG
#endregion
- private void mySubscribe(params string[] tags)
- {
+ private void mySubscribe(params string[] tags) {
SubMetaData sub = new SubMetaData(myConnection.clientURL, tags);
Stream str = new MemoryStream();
new MetaData(sub).save(str);
@@ -135,20 +116,16 @@ namespace BCG
myConnection.send(str);
}
- private void myHandleServerReboot(string serverURL, bool connection)
- {
- if (connection)
- {
+ private void myHandleServerReboot(string serverURL, bool connection) {
+ if (connection) {
//ie connection established again, so has to
//resubscribe to all the tags
// BlueEventLog.logEvent("Connection to " + serverURL + " established....resubscribing to all the tags",
// PS3LogLevels.disconnection);
mySubscribe(myTags.ToArray());
-
- }
- else
- {
+
+ } else {
// BlueEventLog.logEvent("Connection to " + serverURL + " broke....attempting to reconnect...",
// PS3LogLevels.disconnection);
}
@@ -158,18 +135,17 @@ namespace BCG
onPubSubConnectionChange(connection, serverURL);
}
- internal static void processMessage(byte[] data, List updates)
- {
- if (data != null && data.Length > 0)
- {
+ internal static void processMessage(byte[] data, List updates) {
+ bts.Log.Gen.info($"SingleServerSubscriberCore.processMessage data_len: {data.Length}");
+ if (data != null && data.Length > 0) {
MemoryStream str = new MemoryStream(data);
MetaData md = new MetaData(str);
+ bts.Log.Gen.info($"SingleServerSubscriberCore.processMessage meta_data: {md}");
MemoryStream bodyStream = str;
long bodyPosition = str.Position;
- object op = Activator.CreateInstance (Type.GetType("BCG." + md["op-code"]));
+ object op = Activator.CreateInstance(Type.GetType("BCG." + md["op-code"]));
md.copyTo(op);
- if (op is PubMetaData)
- {
+ if (op is PubMetaData) {
PubMetaData p = op as PubMetaData;
//BCG.BlueTrace.WriteBlueCommReceiveW(p.tag, p.publishTimeTicks);
@@ -177,41 +153,29 @@ namespace BCG
p.warnIfLatencyExceedsThreshold();
//find out if we need to decompress this data
Stream realBody = bodyStream;
- if (p.isCompressed)
- {
+ if (p.isCompressed) {
long compressedSize = bodyStream.Length - bodyStream.Position;
- if (compressedSize == 0)
- {
+ if (compressedSize == 0) {
string errorMsg = "Error: tag " + p.tag + " had compressed size of 0 bytes. This shouldnt' happen. Not decompressing tag or sending out update.";
Console.WriteLine(errorMsg);
//BlueEventLog.logEvent(errorMsg, BlueEventLevel.Error);
return;
-
-
}
-
realBody = StreamDecompressor.decompressStream(bodyStream);
realBody.Position = bodyPosition;
}
-
-
-
updates.Add(new PubSubUpdate(p.tag, p.type, realBody));
- }
- else if (op is TransactionMetaData)
- {
+ } else if (op is TransactionMetaData) {
TransactionMetaData tr = op as TransactionMetaData;
- for (int i = 0; i < tr.nMessages; i++)
- {
+ for (int i = 0; i < tr.nMessages; i++) {
PubMetaData pub = new PubMetaData();
new MetaData(bodyStream).copyTo(pub);
byte[] trConstituent = new byte[pub.size];
bodyStream.Read(trConstituent, 0, trConstituent.Length);
updates.Add(new PubSubUpdate(pub.tag, pub.type, new MemoryStream(trConstituent)));
}
- }
- else{}
- //BlueEventLog.logAssert(false, "Unknown message received: " + md.ToString() + " , only Pub and TransactionMetaData are legal");
+ } else { }
+ //BlueEventLog.logAssert(false, "Unknown message received: " + md.ToString() + " , only Pub and TransactionMetaData are legal");
}
}
}
diff --git a/src/DataStreamSuite/PubSub/StaticPublisherCore.cs b/src/DataStreamSuite/PubSub/StaticPublisherCore.cs
index 57ff7459b..5c8713f6e 100644
--- a/src/DataStreamSuite/PubSub/StaticPublisherCore.cs
+++ b/src/DataStreamSuite/PubSub/StaticPublisherCore.cs
@@ -15,91 +15,79 @@ using mbts;
* This file was originally called 'PublisherCore.cs'. It was renamed so that the publisher core could be replaced.
*
* */
-namespace BCG
-{
- public class CrushedTagManager
- {
- private static CrushedTagManager mySelf;
- private Dictionary myTags = new Dictionary();
- public static CrushedTagManager instance
- {
- get
- {
- if (mySelf == null)
- mySelf = new CrushedTagManager();
- return mySelf;
+namespace BCG {
+ // Provides a function to check if a tag is crushabel or not
+ public class CrushedTagManager {
+ private static CrushedTagManager _self;
+ private Dictionary _tag_map = new Dictionary();
+ public static CrushedTagManager instance {
+ get {
+ if (_self == null)
+ _self = new CrushedTagManager();
+ return _self;
}
}
- public bool isTagCrushable(string tag)
- {
+ public bool is_tag_crushable(string tag) {
tag = tag.ToLower();
- lock (typeof(CrushedTagManager))
- {
- if (!myTags.ContainsKey(tag))
- {
+ bool rv = false;
+ lock (typeof(CrushedTagManager)) {
+ if (!_tag_map.TryGetValue(tag, out rv)) {
foreach (string r in PubSub3Config.instance.PS3_CrushableTags)
- if (new System.Text.RegularExpressions.Regex(r).IsMatch(tag))
- {
- myTags.Add(tag, true);
+ if (new System.Text.RegularExpressions.Regex(r).IsMatch(tag)) {
+ _tag_map.Add(tag, true);
break;
}
- if (!myTags.ContainsKey(tag))
- myTags.Add(tag, false);
+ _tag_map.Add(tag, false);
}
}
- return myTags[tag];
+ return rv;
}
}
///
/// All the data for a single tag, thats published within
/// a transaction
///
- public class TagWaitingInTransaction
- {
- private bool myIsCrushable;
- private List myData = new List();
- private int myTotalSize = 0;
- private string myTag, myTagType;
- public TagWaitingInTransaction(string theTagType, string theTag)
- {
- myTag = theTag;
- myTagType = theTagType;
- myIsCrushable = CrushedTagManager.instance.isTagCrushable(myTag);
+ public class TagWaitingInTransaction {
+ private bool _is_crushable;
+ private List _buffered_data = new List();
+ // this is the size of all the buffered data
+ private int _total_size = 0;
+ private string _tag, _tag_type;
+ public TagWaitingInTransaction(string theTagType, string theTag) {
+ _tag = theTag;
+ _tag_type = theTagType;
+ _is_crushable = CrushedTagManager.instance.is_tag_crushable(_tag);
}
- public void addPub(Stream pubStream)
- {
- if (myIsCrushable)
- {
- byte[] newData = new byte[(int)(pubStream.Length - pubStream.Position)];
- pubStream.Read(newData, 0, newData.Length);
- myData.Clear();
- myData.Add(newData);
- myTotalSize = newData.Length;
- }
- else
- {
- byte[] newData = new byte[(int)(pubStream.Length - pubStream.Position)];
- pubStream.Read(newData, 0, newData.Length);
- myData.Add(newData);
- myTotalSize += newData.Length;
+ public void add_pub(Stream pub_stream) {
+ if (_is_crushable) {
+ // extract bytes, clear _buffered_data and queue to _buffered_data
+ byte[] new_data = new byte[(int)(pub_stream.Length - pub_stream.Position)];
+ pub_stream.Read(new_data, 0, new_data.Length);
+ _buffered_data.Clear();
+ _buffered_data.Add(new_data);
+ _total_size = new_data.Length;
+ } else {
+ // extract btes and queue to _buffered_data
+ byte[] new_data = new byte[(int)(pub_stream.Length - pub_stream.Position)];
+ pub_stream.Read(new_data, 0, new_data.Length);
+ _buffered_data.Add(new_data);
+ _total_size += new_data.Length;
}
}
- public void writeTo(Stream s, string connection, string publishingApp)
- {
- new MetaData(new PubMetaData(myTagType, myTag, myTotalSize, connection, publishingApp)).save(s);
- foreach (byte[] data in myData)
+ public void write_to(Stream s, string connection, string publishing_app) {
+ new MetaData(new PubMetaData(_tag_type, _tag, _total_size, connection, publishing_app)).save(s);
+ foreach (byte[] data in _buffered_data)
s.Write(data, 0, data.Length);
}
- public string tag { get { return myTag; } }
- public string tagType { get { return myTagType; } }
- public List data { get { return myData; } }
+ public string tag { get { return _tag; } }
+ public string tagType { get { return _tag_type; } }
+ public List data { get { return _buffered_data; } }
}
- public enum PublisherCoreMessageType
- {
+ public enum PublisherCoreMessageType {
transactionBegin,
transactionCommit,
transactionAbort,
@@ -107,26 +95,22 @@ namespace BCG
clear
}
- public class PublisherCoreMessage
- {
+ public class PublisherCoreMessage {
public PublisherCoreMessageType msgType;
public string tagType, tag;
public Stream data;
- public PublisherCoreMessage(string tagToClear)
- {
+ public PublisherCoreMessage(string tagToClear) {
tag = tagToClear;
msgType = PublisherCoreMessageType.clear;
}
- public PublisherCoreMessage(PublisherCoreMessageType theMsgType)
- {
+ public PublisherCoreMessage(PublisherCoreMessageType theMsgType) {
msgType = theMsgType;
}
- public PublisherCoreMessage(string theTagType, string theTag, Stream theData)
- {
+ public PublisherCoreMessage(string theTagType, string theTag, Stream theData) {
msgType = PublisherCoreMessageType.publish;
tagType = theTagType;
tag = theTag;
@@ -136,8 +120,7 @@ namespace BCG
// this class uses an internal queue + thread to serialize and process calls
// made through its public interface (IPublisherCore)
- public class StaticPublisherCore : IPublisherCore
- {
+ public class StaticPublisherCore : IPublisherCore {
// used to allow for different transports
// to be used when communicating to a pubsubserver
protected PubSubServerConnectionFactory myConnectionFactory = new PubSubServerConnectionFactory(false);
@@ -172,57 +155,46 @@ namespace BCG
public StaticPublisherCore()
// TODOds
- : this(new PubSubRouter())
- { }
+ : this(new PubSubRouter()) { }
public StaticPublisherCore(string serverURL)
- : this(new PubSubRouter(new PubSubRoute(serverURL, ".*")))
- { }
+ : this(new PubSubRouter(new PubSubRoute(serverURL, ".*"))) { }
- public StaticPublisherCore(IPubSubRouter r)
- {
+ public StaticPublisherCore(IPubSubRouter r) {
myRouter = r;
Thread pumpThread = new Thread(new ThreadStart(myMessagePump));
pumpThread.IsBackground = true;
pumpThread.Start();
}
- public void Dispose()
- { }
+ public void Dispose() { }
#endregion
public int getNumberOfWaitingMessages() { return myMainQueue.getCount(); }
#region Main Thread - all library functions are called on the main thread and queued to be picked by the pump
- public void publish(string tag, Stream content)
- { publish("", tag, content); }
+ public void publish(string tag, Stream content) { publish("", tag, content); }
- public void publish(string tagType, string tag, Stream content)
- {
+ public void publish(string tagType, string tag, Stream content) {
myMainQueue.enqueue(new PublisherCoreMessage(tagType, tag, content));
}
- public void beginTransaction()
- {
+ public void beginTransaction() {
myMainQueue.enqueue(new PublisherCoreMessage(PublisherCoreMessageType.transactionBegin));
}
- public void commitTransaction()
- {
+ public void commitTransaction() {
myMainQueue.enqueue(new PublisherCoreMessage(PublisherCoreMessageType.transactionCommit));
}
- public void abortTransaction()
- {
+ public void abortTransaction() {
myMainQueue.enqueue(new PublisherCoreMessage(PublisherCoreMessageType.transactionAbort));
}
- public bool inTransaction
- { get { return myInTransaction; } }
+ public bool inTransaction { get { return myInTransaction; } }
- public void clearState(string tag)
- {
+ public void clearState(string tag) {
myMainQueue.enqueue(new PublisherCoreMessage(tag));
}
@@ -230,49 +202,32 @@ namespace BCG
#region Message Pump Thread - this is where messages are dequeued and the action performed
- private void myMessagePump()
- {
- while (true)
- {
- try
- {
- while (true)
- {
+ private void myMessagePump() {
+ while (true) {
+ try {
+ while (true) {
object data = myMainQueue.dequeue(1000);
- if (data != null)
- {
+ if (data != null) {
int qc = myMainQueue.getCount();
PublisherCoreMessage msg = data as PublisherCoreMessage;
- if (msg.msgType == PublisherCoreMessageType.transactionBegin)
- {
+ if (msg.msgType == PublisherCoreMessageType.transactionBegin) {
myBeginTransaction();
- }
- else if (msg.msgType == PublisherCoreMessageType.transactionCommit)
- {
+ } else if (msg.msgType == PublisherCoreMessageType.transactionCommit) {
myCommitTransaction();
- }
- else if (msg.msgType == PublisherCoreMessageType.transactionAbort)
- {
+ } else if (msg.msgType == PublisherCoreMessageType.transactionAbort) {
myAbortTransaction();
- }
- else if (msg.msgType == PublisherCoreMessageType.publish)
- {
+ } else if (msg.msgType == PublisherCoreMessageType.publish) {
myPublish(msg.tagType, msg.tag, msg.data);
- }
- else if (msg.msgType == PublisherCoreMessageType.clear)
- {
+ } else if (msg.msgType == PublisherCoreMessageType.clear) {
myClearState(msg.tag);
}
}
- foreach (IPubSubServerConnection conn in mySenders)
- {
+ foreach (IPubSubServerConnection conn in mySenders) {
conn.doWork();
}
}
- }
- catch (Exception ex)
- {
+ } catch (Exception ex) {
// BlueEventLog.logEvent(ex);
if (ex is OutOfMemoryException)
throw ex;
@@ -280,20 +235,17 @@ namespace BCG
}
}
- private void myBeginTransaction()
- {
+ private void myBeginTransaction() {
// BlueEventLog.logAssert(!inTransaction);
//BlueEventLog.logEvent("StaticPublisherCore Starting Transaction.", BlueEventLevel.Information);
myInTransaction = true;
}
- private void myCommitTransaction()
- {
+ private void myCommitTransaction() {
myEndTransaction(true);
}
- private void myAbortTransaction()
- {
+ private void myAbortTransaction() {
myEndTransaction(false);
}
@@ -304,21 +256,17 @@ namespace BCG
//keep it consistent with the way it was done earlier), this should
//simply publish it non transactionally (easy way out), or
//transactionally with respect to each pubsub
- protected virtual void myEndTransaction(bool success)
- {
- lock (this)
- {
+ protected virtual void myEndTransaction(bool success) {
+ lock (this) {
// BlueEventLog.logAssert(inTransaction);
//BlueEventLog.logEvent("StaticPublisherCore Finishing Transaction.", BlueEventLevel.Information);
myInTransaction = false;
- if (success)
- {
+ if (success) {
// pubsub server -> tags with updates
Dictionary> routesToTags = new Dictionary>();
// group updates per pubsub server
- foreach (string tag in myWaitingInTransactionMessages.Keys)
- {
+ foreach (string tag in myWaitingInTransactionMessages.Keys) {
string thisURL = myRouter.getPubURLForTag(tag);
if (!routesToTags.ContainsKey(thisURL))
routesToTags[thisURL] = new List();
@@ -327,17 +275,14 @@ namespace BCG
// more than one server means we won't be able to honor the transactionality request
// log a warning if that is the case.
- if (routesToTags.Keys.Count > 1)
- {
+ if (routesToTags.Keys.Count > 1) {
//this is going to be a long error message, but it's an importat one to be able to debug.
StringBuilder errorMessageBuilder = new StringBuilder();
errorMessageBuilder.Append("Tags within this transaction are routed to different pubSub servers.\n");
errorMessageBuilder.Append("This will break the transactionality of clients receiving the data. Details:\n");
- foreach (string route in routesToTags.Keys)
- {
- foreach (string tag in routesToTags[route])
- {
+ foreach (string route in routesToTags.Keys) {
+ foreach (string tag in routesToTags[route]) {
errorMessageBuilder.Append("\tTag ");
errorMessageBuilder.Append(tag);
errorMessageBuilder.Append(" is routed to ");
@@ -351,16 +296,14 @@ namespace BCG
}
// iterate through each server with pending messages
- foreach (KeyValuePair> kvp in routesToTags)
- {
+ foreach (KeyValuePair> kvp in routesToTags) {
IPubSubServerConnection transactionSender = null;
string publishingApp = ClientInfo.thisClient.processString;
string connection = kvp.Key;
Stream transactionData = new MemoryStream();
// iterate through each of the pending tag updates for one server
- foreach (string tag in kvp.Value)
- {
+ foreach (string tag in kvp.Value) {
///it would be the same transaction sender that would
///return each time
transactionSender = myGetOrBuildSender(tag);
@@ -372,7 +315,7 @@ namespace BCG
// update internal state
myState.publish(waiting.tag, waiting.tagType, data);
// add a pubsub header and copy each message to the transactionData stream
- waiting.writeTo(transactionData, connection, publishingApp);
+ waiting.write_to(transactionData, connection, publishingApp);
}
// now transactionData holds all the updates for all the tags
// that are to be sent to the PubSub represented by transactionSender
@@ -384,35 +327,32 @@ namespace BCG
transactionData.Position = 0;
// send the entire thing to the specific pubsub server.
- transactionSender.send(new PubSubMessage(new MetaData(tMd), transactionData).toStream());
+ // this is where the data is actually sent out !
+ var ps_msg = new PubSubMessage(new MetaData(tMd), transactionData);
+ Console.WriteLine($"serverConn.send metadata: {ps_msg.meta_data}");
+ bts.Log.Gen.info($"serverConn.send metadata: {ps_msg.meta_data}");
+ transactionSender.send(ps_msg);
}
}
myWaitingInTransactionMessages.Clear();
}
}
- protected virtual void myPublish(string tagType, string tag, Stream content)
- {
- if (myInTransaction)
- {
+ protected virtual void myPublish(string tagType, string tag, Stream content) {
+ if (myInTransaction) {
///if its in transaction message is cached, and is sent
///only when theres a commit or abort
if (!myWaitingInTransactionMessages.ContainsKey(tag))
myWaitingInTransactionMessages.Add(tag, new TagWaitingInTransaction(tagType, tag));
- myWaitingInTransactionMessages[tag].addPub(content);
- }
- else
- {
+ myWaitingInTransactionMessages[tag].add_pub(content);
+ } else {
//if (CrushedTagManager.instance.isTagCrushable(tag))
{
myState.publish(tag, tagType, content);
- if (!myCrushableTagsWaitingOnAck.ContainsKey(tag))
- {
+ if (!myCrushableTagsWaitingOnAck.ContainsKey(tag)) {
// BlueEventLog.logEvent("Sending crushable tag " + tag, BlueEventLevel.Diagnosis);
mySendData(tag, tagType, content);
- }
- else
- {
+ } else {
// BlueEventLog.logEvent("Could not send tag " + tag + " since its waiting on an ack", BlueEventLevel.Diagnosis);
myCrushableTagsWaitingOnAck[tag].second++;
}
@@ -428,64 +368,59 @@ namespace BCG
}
// add header, possibly compress the data, and sendto appropriate pubsub
- private void mySendData(string tag, string tagType, Stream content)
- {
+ private void mySendData(string tag, string tagType, Stream content) {
long initPos = content.Position;
// locate right pubsub for this tag
IPubSubServerConnection serverConn = myGetOrBuildSender(tag);
Stream contentToPublish = content;
- PubMetaData pubMd;
+ PubMetaData pub_md;
- if (PubSub3Config.instance.isTagCompressed(tag))
- {
+ if (PubSub3Config.instance.isTagCompressed(tag)) {
contentToPublish = new MemoryStream();
SharpZipCompressor Kompressor = new SharpZipCompressor();
Kompressor.compress(content, contentToPublish);
contentToPublish.Position = 0;
- pubMd = new PubMetaData(tagType, tag, (int)contentToPublish.Length, (int)content.Length, serverConn.serverURL, ClientInfo.thisClient.processString);
- if (PubSub3Config.instance.shouldReportTagsCompressionRatio(tag))
- {
+ pub_md = new PubMetaData(tagType, tag, (int)contentToPublish.Length, (int)content.Length, serverConn.serverURL, ClientInfo.thisClient.processString);
+ if (PubSub3Config.instance.shouldReportTagsCompressionRatio(tag)) {
string msg = String.Format("Compressed tag {0} from {1} to {2} bytes, for a ratio of {3}.", tag, content.Length, contentToPublish.Length, (float)content.Length / (float)contentToPublish.Length);
// BlueEventLog.logEvent(msg, PS3LogLevels.compressionRatio);
}
- }
- else
- pubMd = new PubMetaData(tagType, tag, (int)content.Length, serverConn.serverURL, ClientInfo.thisClient.processString);
+ } else
+ pub_md = new PubMetaData(tagType, tag, (int)content.Length, serverConn.serverURL, ClientInfo.thisClient.processString);
content.Position = initPos;
- if (CrushedTagManager.instance.isTagCrushable(tag))
- {
+ if (CrushedTagManager.instance.is_tag_crushable(tag)) {
string refId = String.Empty;
Console.WriteLine("StaticPublisherCore.mySend serverConn.sendWithConfirmation tag: " + tag + " server: " + serverConn.serverURL);
- serverConn.sendWithConfirmation((new PubSubMessage(new MetaData(pubMd), contentToPublish).toStream() as MemoryStream).ToArray(), ref refId);
+ // this is where the data is actually sent out (there are multiple sends)
+ PubSubMessage ps_msg = new PubSubMessage(new MetaData(pub_md), contentToPublish);
+ //Console.WriteLine($"serverConn.send_with_confirmation metadata: {ps_msg.meta_data}");
+ bts.Log.Gen.info($"serverConn.send_with_confirmation metadata: {ps_msg.meta_data}");
+ serverConn.send_with_confirmation(ps_msg, ref refId);
myCrushableTagsWaitingOnAck.Add(tag, new Pair(refId, 0));
- }
- else
- {
- Console.WriteLine("StaticPublisherCore.mySend serverConn.send tag: " + tag + " server: " + serverConn.serverURL);
- serverConn.send(new PubSubMessage(new MetaData(pubMd), contentToPublish).toStream());
+ } else {
+ //Console.WriteLine("StaticPublisherCore.mySend serverConn.send tag: " + tag + " server: " + serverConn.serverURL);
+ // this is where the data is actually sent out
+ var ps_msg = new PubSubMessage(pub_md, contentToPublish);
+ bts.Log.Gen.info($"serverConn.send metadata: {ps_msg}");
+ Console.WriteLine($"serverConn.send metadata: {ps_msg}");
+ serverConn.send(ps_msg);
}
}
- private void myClearState(string tag)
- {
- if (myTagToSender.ContainsKey(tag))
- {
+ private void myClearState(string tag) {
+ if (myTagToSender.ContainsKey(tag)) {
myTagToSender.Remove(tag);
}
myState.clear(tag);
-
}
- protected virtual IPubSubServerConnection myGetOrBuildSender(string tag)
- {
- if (!myTagToSender.ContainsKey(tag))
- {
+ protected virtual IPubSubServerConnection myGetOrBuildSender(string tag) {
+ if (!myTagToSender.ContainsKey(tag)) {
string route = myRouter.getPubURLForTag(tag);
IPubSubServerConnection sender = myConnectionFactory.getConnection(route);
myTagToSender.Add(tag, sender);
- if (!mySenders.Contains(sender))
- {
+ if (!mySenders.Contains(sender)) {
mySenders.Add(sender);
sender.registerCallback(new ConnectionStatusChange(myHandleServerReboot));
sender.registerSendConfirmationCallback(new SendConfirmationDelegate(myOnSendConfirm));
@@ -497,15 +432,11 @@ namespace BCG
///in case of the server coming up, it publishes all the stored state
///for that server, back to it
- protected void myHandleServerReboot(string serverURL, bool connection)
- {
- if (connection)
- {
+ protected void myHandleServerReboot(string serverURL, bool connection) {
+ if (connection) {
string thisPublisherInfo = ClientInfo.thisClient.processString;
- foreach (KeyValuePair p in myTagToSender)
- {
- if (p.Value.serverURL == serverURL)
- {
+ foreach (KeyValuePair p in myTagToSender) {
+ if (p.Value.serverURL == serverURL) {
string tagType;
string tag = p.Key;
myCrushableTagsWaitingOnAck.Clear();
@@ -547,16 +478,12 @@ namespace BCG
/// of waiting for ack
///
private Dictionary> myCrushableTagsWaitingOnAck = new Dictionary>();
- private void myOnSendConfirm(string messageId, bool confirmed)
- {
- foreach (string tag in new List(myCrushableTagsWaitingOnAck.Keys))
- {
+ private void myOnSendConfirm(string messageId, bool confirmed) {
+ foreach (string tag in new List(myCrushableTagsWaitingOnAck.Keys)) {
Pair tagData = myCrushableTagsWaitingOnAck[tag];
- if (messageId == tagData.first)
- {
+ if (messageId == tagData.first) {
myCrushableTagsWaitingOnAck.Remove(tag);
- if (tagData.second > 0)
- {
+ if (tagData.second > 0) {
// BlueEventLog.logEvent("Missed sending " + tagData.second + " messages, sending latest message now", BlueEventLevel.Diagnosis);
/// this data was waiting on an
/// ack, need to resend it
diff --git a/src/DataStreamSuite/PubSub/Client/SimpleTCPClient.cs b/src/DataStreamSuite/PubSub/Testing/SimpleTCPClient.cs
similarity index 76%
rename from src/DataStreamSuite/PubSub/Client/SimpleTCPClient.cs
rename to src/DataStreamSuite/PubSub/Testing/SimpleTCPClient.cs
index 5f9e2a31f..49043d8d1 100644
--- a/src/DataStreamSuite/PubSub/Client/SimpleTCPClient.cs
+++ b/src/DataStreamSuite/PubSub/Testing/SimpleTCPClient.cs
@@ -10,42 +10,52 @@ using Spark.Core.Reactive;
using System.Security.Cryptography.X509Certificates;
using BCG;
-namespace BCG {
+namespace BCG
+{
// This uses AsyncTCPConnection2's stateful async functions
- public class SimpleTCPClientAsync : ITCPConnectionHandler, ITCPMessageHandler {
+ public class SimpleTCPClientAsync : ITCPConnectionHandler, ITCPMessageHandler
+ {
AsyncTCPConnection2 _conn = null;
int _m_msgs_received = 0;
- public static async Task start(string ip, int port) {
+ public static async Task start(string ip, int port)
+ {
SimpleTCPClientAsync c = new SimpleTCPClientAsync(ip, port);
c.connect();
}
- public void connect() {
+ public void connect()
+ {
Task.Run(async () => await TCPSocketUtils.connect_to_server_async("127.0.0.1", 12345, this, TimeSpan.FromSeconds(2)));
}
- public void onConnection(ITCPConnection connection) {
+ public void onConnection(ITCPConnection connection)
+ {
Console.WriteLine("SimpleTCPClientAsync.onConnection connected to server, starting task to send data in a loop");
connection.register(this);
// start sending data
- Task.Run(async () => {
+ Task.Run(async () =>
+ {
byte[] buff = new byte[1024];
- for (int i = 0; i < buff.Length; i++) {
+ for (int i = 0; i < buff.Length; i++)
+ {
buff[i] = (byte)i;
}
_conn = connection as AsyncTCPConnection2;
- while (!_conn.isDisposed) {
+ while (!_conn.isDisposed)
+ {
await _conn.send_async(buff);
await Task.Delay(100);
}
});
}
- public void onData(RemoteMessage msg) {
+ public void onData(RemoteMessage msg)
+ {
_m_msgs_received++;
Console.WriteLine($"SimpleTCPClientAsync.onData n_msgs: {_m_msgs_received} msg: {msg}");
- if (msg.messageType == RemoteMessageType.disconnection) {
+ if (msg.messageType == RemoteMessageType.Disconnection)
+ {
connect();
}
}
@@ -57,31 +67,37 @@ namespace BCG {
public SimpleTCPClientAsync(string ip, int port) { }
}
- public class SimpleTCPClient : ITCPConnectionHandler, ITCPMessageHandler {
+ public class SimpleTCPClient : ITCPConnectionHandler, ITCPMessageHandler
+ {
private int _n_msgs_received = 0;
AsyncTCPConnection2 _conn = null;
- public static void start(string ip, int port) {
+ public static void start(string ip, int port)
+ {
SimpleTCPClient c = new SimpleTCPClient(ip, port);
c.connect();
}
- public void connect() {
+ public void connect()
+ {
Console.WriteLine("SimpleTCPClient.onConnection connect() called");
ClientToServerManagedTCPConnector.connect_to(new BlutoSubAddress("bluto://127.0.0.1:12345"), this, TimeSpan.FromSeconds(1));
}
- public void onConnection(ITCPConnection connection) {
+ public void onConnection(ITCPConnection connection)
+ {
_conn = connection as AsyncTCPConnection2;
Console.WriteLine("SimpleTCPClient.onConnection connected to server, starting task to send data in a loop");
_conn.register(this);
byte[] buff = new byte[1024];
- for (int i = 0; i < buff.Length; i++) {
+ for (int i = 0; i < buff.Length; i++)
+ {
buff[i] = (byte)i;
}
- while (!_conn.isDisposed) {
+ while (!_conn.isDisposed)
+ {
_conn.send(buff);
System.Threading.Thread.Sleep(1000);
}
@@ -96,10 +112,12 @@ namespace BCG {
// });
}
- public void onData(RemoteMessage msg) {
+ public void onData(RemoteMessage msg)
+ {
_n_msgs_received++;
Console.WriteLine($"SimpleTCPClient.onData messages received: {_n_msgs_received} msg: {msg} messages received: {_n_msgs_received}");
- if (msg.messageType == RemoteMessageType.disconnection) {
+ if (msg.messageType == RemoteMessageType.Disconnection)
+ {
connect();
}
}
diff --git a/src/DataStreamSuite/PubSub/Server/SimpleTCPServer.cs b/src/DataStreamSuite/PubSub/Testing/SimpleTCPServer.cs
similarity index 92%
rename from src/DataStreamSuite/PubSub/Server/SimpleTCPServer.cs
rename to src/DataStreamSuite/PubSub/Testing/SimpleTCPServer.cs
index 5be508b39..4cb24c4fc 100644
--- a/src/DataStreamSuite/PubSub/Server/SimpleTCPServer.cs
+++ b/src/DataStreamSuite/PubSub/Testing/SimpleTCPServer.cs
@@ -16,14 +16,17 @@ using System.Reflection;
using System.Data;
using System.Collections.Generic;
-namespace BCG {
+namespace BCG
+{
- public class SimpleTCPServerAsync : ITCPConnectionHandler, ITCPMessageHandler {
+ public class SimpleTCPServerAsync : ITCPConnectionHandler, ITCPMessageHandler
+ {
int _n_msgs_received = 0;
SingleServerToClientManagedTCPConnectionAcceptor _acceptor = new SingleServerToClientManagedTCPConnectionAcceptor();
IDictionary _conn_map = new Dictionary();
- public static async Task start() {
+ public static async Task start()
+ {
Console.WriteLine("SimpleTCPServer.start accepting socket connections");
SimpleTCPServerAsync s = new SimpleTCPServerAsync();
@@ -35,11 +38,13 @@ namespace BCG {
// {
// }
- public void accept() {
+ public void accept()
+ {
_acceptor.accept_on_port(this, "127.0.0.1", 12345, TimeSpan.Zero);
}
- public void onConnection(ITCPConnection connection) {
+ public void onConnection(ITCPConnection connection)
+ {
AsyncTCPConnection2 new_conn = connection as AsyncTCPConnection2;
RemoteConnectionInfo rci = new_conn.get_peer_address();
_conn_map.Add(rci, new_conn);
@@ -48,18 +53,21 @@ namespace BCG {
}
- public void onData(RemoteMessage msg) {
+ public void onData(RemoteMessage msg)
+ {
Console.WriteLine($"SimpleTCPServerAsync.onData msg: {msg}");
RemoteConnectionInfo rci = msg.remoteConnectionInfo;
ITCPConnection this_conn;
bool found = _conn_map.TryGetValue(rci, out this_conn);
- if (!found) {
+ if (!found)
+ {
Console.WriteLine("Could not find connection !!!!!!");
return;
}
_n_msgs_received++;
Console.WriteLine($"SimpleTCPServerAsync.onData msgs_received: {_n_msgs_received} msg: {msg} ci: {rci} echoing it back");
- if (msg.messageType == RemoteMessageType.data) {
+ if (msg.messageType == RemoteMessageType.Data)
+ {
this_conn.send(msg.message);
// Task.Run(async () => {
diff --git a/src/DataStreamSuite/PubSub/Testing/TestPublisher.cs b/src/DataStreamSuite/PubSub/Testing/TestPublisher.cs
new file mode 100644
index 000000000..f7ee5edf4
--- /dev/null
+++ b/src/DataStreamSuite/PubSub/Testing/TestPublisher.cs
@@ -0,0 +1,50 @@
+using BCG;
+
+using bts;
+
+using System;
+using System.IO;
+using System.Runtime.Serialization;
+
+namespace BCG {
+ public class TestPubItem : IPubItem {
+ int i = 100;
+
+
+ public static string test_tag = "TestTag";
+ public string getTag() {
+ return test_tag;
+ }
+
+ public void to_stream(Stream str) {
+ BinaryWriter bw = new BinaryWriter(str);
+ //bw.Write(d);
+ bw.Write(i);
+ }
+ }
+ public class TestPublisher {
+ TestPubItem _tbi = new TestPubItem();
+ IPublisherCore pcore = new StaticPublisherCore();
+ bool _hit_key_to_send = false;
+ public TestPublisher(bool hit_key_to_send) {
+ _hit_key_to_send = hit_key_to_send;
+ bts.Log.Gen.info($"Started TestPubliser _hit_key_to_send: {_hit_key_to_send}");
+ }
+
+ public void keep_publishing(TimeSpan wait_per, int n_pubs = System.Int32.MaxValue) {
+ TestPubItem pi = new TestPubItem();
+ for (int i = 0; i < n_pubs; i++) {
+ if (_hit_key_to_send) {
+ Console.WriteLine("Hit key to send data");
+ Console.ReadLine();
+ }
+ MemoryStream ms = new MemoryStream();
+ pi.to_stream(ms);
+ ms.Position = 0;
+ pcore.publish(TestPubItem.test_tag, ms);
+ if (!_hit_key_to_send)
+ System.Threading.Thread.Sleep(wait_per);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/DataStreamSuite/PubSub/Testing/TestSubscriber.cs b/src/DataStreamSuite/PubSub/Testing/TestSubscriber.cs
new file mode 100644
index 000000000..2aa4d6781
--- /dev/null
+++ b/src/DataStreamSuite/PubSub/Testing/TestSubscriber.cs
@@ -0,0 +1,38 @@
+using BCG;
+
+using bts;
+
+using System;
+using System.IO;
+using System.Runtime.Serialization;
+
+namespace BCG
+{
+
+ public class TestSubscriber
+ {
+ SubscriberCore _sub_core = new SubscriberCore();
+ public TestSubscriber()
+ {
+ bts.Log.Gen.info("Started TestSubscriber");
+ }
+
+ public void keep_polling(TimeSpan wait_per, int n_polls = System.Int32.MaxValue)
+ {
+ _sub_core.subscribe(TestPubItem.test_tag);
+ for (int i = 0; i < n_polls; i++)
+ {
+ var list = _sub_core.getUpdates();
+ if (list.Count > 0)
+ {
+ Console.WriteLine($"Received {list.Count} items");
+ }
+ foreach (var p in list)
+ {
+ Console.WriteLine($"Received item: {p}");
+ }
+ System.Threading.Thread.Sleep(wait_per);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/src/DataStreamSuite/PubSubServer/Program.cs b/src/DataStreamSuite/PubSubServer/Program.cs
index 62ff4b560..1a7bc86bf 100644
--- a/src/DataStreamSuite/PubSubServer/Program.cs
+++ b/src/DataStreamSuite/PubSubServer/Program.cs
@@ -15,8 +15,10 @@ namespace BCG {
///
[STAThread]
public static async Task Main(string[] args) {
- SimpleTCPServerAsync.start();
- Task.Delay(1000000000).Wait();
+ bts.utils.BTSNativeMethods.provide_command_line(new string[] { }, 0);
+ mbts.config.Configuration.initialize();
+ // SimpleTCPServerAsync.start();
+ // Task.Delay(1000000000).Wait();
if (args.Length > 0 && args[0] == "daemon")
args = args.Skip(1).ToArray();