diff --git a/src/DataStreamSuite/DataStreamTests/PubSubMessages/PuSubMessagesTests.cs b/src/DataStreamSuite/DataStreamTests/PubSubMessages/PuSubMessagesTests.cs new file mode 100644 index 000000000..f329fde27 --- /dev/null +++ b/src/DataStreamSuite/DataStreamTests/PubSubMessages/PuSubMessagesTests.cs @@ -0,0 +1,114 @@ +using NUnit.Framework; + +using System.Reactive.Disposables; + +namespace bts { + [TestFixture] + public class PubSubMessageTests { + static void compare_arrays(IEnumerable col1, IEnumerable col2) { + Assert.AreEqual(col1.Count(), col2.Count()); + int i = 0; + foreach (var t in col1) { + Assert.AreEqual(t, col2.ElementAt(i++)); + } + } + + static byte[] create_byte_array() { + Random random = new Random(); + var sz = random.Next();// % 1000; + + // Generate a random byte + byte randomByte = (byte)random.Next(byte.MinValue, byte.MaxValue + 1); + byte[] rv = new byte[sz]; + for (int i = 0; i < sz; i++) { + rv[i] = (byte)random.Next(byte.MinValue, byte.MaxValue + 1); + } + return rv; + } + + [Test] + public static void test_subscribe_msg() { + // Console.WriteLine("Hit Enter to continue"); + // Console.ReadLine(); + bts.SubscribeMsg sub_msg = new SubscribeMsg() { + connection = "abc", + subscribing_app = "123", + tags = new string[] { "one", "two", "three" } + }; + bts.Log.Gen.info("SubscribeMsg: {sub_msg}"); + MemoryStream str = new MemoryStream(); + sub_msg.serialize_into_str(str); + str.Position = 0; + var sub_msg_desered = new SubscribeMsg(); + sub_msg_desered.consruct_deserialize(str); + Assert.AreEqual(sub_msg.connection, sub_msg_desered.connection); + Assert.AreEqual(sub_msg.subscribing_app, sub_msg_desered.subscribing_app); + compare_arrays(sub_msg.tags, sub_msg_desered.tags); + } + + [Test] + public static void test_unsubscribe_msg() { + bts.UnsubscribeMsg unsub_msg = new UnsubscribeMsg() { + connection = Guid.NewGuid().ToString(), + subscribing_app = Guid.NewGuid().ToString(), + tags = new string[] { "one", "two", "three" } + }; + bts.Log.Gen.info("SubscribeMsg: {sub_msg}"); + MemoryStream str = new MemoryStream(); + unsub_msg.serialize_into_str(str); + str.Position = 0; + var sub_msg_desered = new SubscribeMsg(); + sub_msg_desered.consruct_deserialize(str); + Assert.AreEqual(unsub_msg.connection, sub_msg_desered.connection); + Assert.AreEqual(unsub_msg.subscribing_app, sub_msg_desered.subscribing_app); + compare_arrays(unsub_msg.tags, sub_msg_desered.tags); + } + + [Test] + public static void test_publish_msg() { + var data_to_publish = create_byte_array(); + var sz = data_to_publish.Length; + PublishMsg pub_msg = new PublishMsg() { + connection = Guid.NewGuid().ToString(), + publishing_app = Guid.NewGuid().ToString(), + tag = Guid.NewGuid().ToString(), + tag_type = "DS_", + is_compressed = false, + publish_time_epoch_ms = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(), + data_to_publish = create_byte_array(), + }; + MemoryStream str = new MemoryStream(); + pub_msg.serialize_into_str(str); + str.Position = 0; + PublishMsg pub_msg_desered = new PublishMsg(); + pub_msg_desered.consruct_deserialize(str); + Assert.AreEqual(pub_msg.connection, pub_msg_desered.connection); + Assert.AreEqual(pub_msg.publishing_app, pub_msg_desered.publishing_app); + Assert.AreEqual(pub_msg.tag, pub_msg_desered.tag); + Assert.AreEqual(pub_msg.tag_type, pub_msg_desered.tag_type); + Assert.AreEqual(pub_msg.is_compressed, pub_msg_desered.is_compressed); + Assert.AreEqual(pub_msg.publish_time_epoch_ms, pub_msg_desered.publish_time_epoch_ms); + Assert.AreEqual(pub_msg.data_to_publish.Length, pub_msg_desered.data_to_publish.Length); + compare_arrays(pub_msg.data_to_publish, pub_msg_desered.data_to_publish); + } + + //[Test] + public static void test_pubsub_server_msg() { + PubSubServerMessage ps_server_msg = new PubSubServerMessage() { + tag = Guid.NewGuid().ToString(), + tag_type = Guid.NewGuid().ToString(), + data = create_byte_array() + }; + MemoryStream str = new MemoryStream(); + ps_server_msg.serialize_into_str(str); + PubSubServerMessage ps_server_msg_desered = new PubSubServerMessage(); + str.Position = 0; + ps_server_msg_desered.consruct_deserialize(str); + Assert.AreEqual(ps_server_msg.tag, ps_server_msg_desered.tag); + Assert.AreEqual(ps_server_msg.tag_type, ps_server_msg_desered.tag_type); + compare_arrays(ps_server_msg.data, ps_server_msg_desered.data); + + + } + } +} \ No newline at end of file diff --git a/src/DataStreamSuite/DataStreamTests/StreamSerialization/UniversalSerializationTest.cs b/src/DataStreamSuite/DataStreamTests/StreamSerialization/UniversalSerializationTest.cs index 9d1da91f5..57f69964a 100644 --- a/src/DataStreamSuite/DataStreamTests/StreamSerialization/UniversalSerializationTest.cs +++ b/src/DataStreamSuite/DataStreamTests/StreamSerialization/UniversalSerializationTest.cs @@ -1,195 +1,195 @@ -using System; -using System.IO; +// using System; +// using System.IO; -using NUnit.Framework; +// using NUnit.Framework; -namespace BCG { +// namespace BCG { - /// - /// Tests the deserialization happening within the pubsub. - /// - public class UniversalSerializationTest { - protected IBlueTableSchema mySchema; - protected BlueTable myTable; - protected IBlueDataSerializer mySer = new BlueDataSerializationController(); - protected IPubsubDeserializer myPubsubDeser = new PubsubDeserializationController(); - protected IClientDeserializer myClientDeser = new ClientDeserializationController(); +// /// +// /// Tests the deserialization happening within the pubsub. +// /// +// public class UniversalSerializationTest { +// protected IBlueTableSchema mySchema; +// protected BlueTable myTable; +// protected IBlueDataSerializer mySer = new BlueDataSerializationController(); +// protected IPubsubDeserializer myPubsubDeser = new PubsubDeserializationController(); +// protected IClientDeserializer myClientDeser = new ClientDeserializationController(); - public UniversalSerializationTest() { - mySchema = new BlueTableSchema(myGetTableName(), - new ColumnInfo("id", 0, typeof(int)), - new ColumnInfo("i1", 1, typeof(int)), - new ColumnInfo("d1", 2, typeof(double)), - new ColumnInfo("dt", 3, typeof(DateTime)), - new ColumnInfo("x", 4, typeof(byte)) - ); - } +// public UniversalSerializationTest() { +// mySchema = new BlueTableSchema(myGetTableName(), +// new ColumnInfo("id", 0, typeof(int)), +// new ColumnInfo("i1", 1, typeof(int)), +// new ColumnInfo("d1", 2, typeof(double)), +// new ColumnInfo("dt", 3, typeof(DateTime)), +// new ColumnInfo("x", 4, typeof(byte)) +// ); +// } - protected virtual string myGetTableName() { - return "testUniversal"; - } +// protected virtual string myGetTableName() { +// return "testUniversal"; +// } - /// - /// Tests the entire cycle. This is done by 'publishing' data to the serializationController (ie a series of - /// adds, deletions, changes etc) and getting the bytes and feeding it into a pubsubDeseriazlier and a clientDeserializer. - /// At every step the data is tested for consistency. At the end the getState is used to get all the data, and its passed - /// through the clientDeserializer to get all the rows. - /// - /// - [Test] - public void testEntireProcess() { - myTable = new BlueTable(mySchema); - byte[] data; - int id; - //create - for (id = 0; id < 100; id++) - myTable.addRow(myGetRow(id)); +// /// +// /// Tests the entire cycle. This is done by 'publishing' data to the serializationController (ie a series of +// /// adds, deletions, changes etc) and getting the bytes and feeding it into a pubsubDeseriazlier and a clientDeserializer. +// /// At every step the data is tested for consistency. At the end the getState is used to get all the data, and its passed +// /// through the clientDeserializer to get all the rows. +// /// +// /// +// [Test] +// public void testEntireProcess() { +// myTable = new BlueTable(mySchema); +// byte[] data; +// int id; +// //create +// for (id = 0; id < 100; id++) +// myTable.addRow(myGetRow(id)); - byte[] ops; - Array rows; - IBlueRowCollection del, add; - IBlueRowCollection[] receivedData; - IBlueRow r; +// byte[] ops; +// Array rows; +// IBlueRowCollection del, add; +// IBlueRowCollection[] receivedData; +// IBlueRow r; - //create - mySer.serialize(StreamOpCode.create, new IBlueRowCollection[] { myTable }, out data); - myWrite(StreamOpCode.create, data); - myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - Assert.AreEqual(1, ops.Length); - Assert.AreEqual(StreamOpCode.create, ops[0]); - Assert.AreEqual(1, rows.Length); - receivedData = rows.GetValue(0) as IBlueRowCollection[]; - Assert.AreEqual(1, receivedData.Length); +// //create +// mySer.serialize(StreamOpCode.create, new IBlueRowCollection[] { myTable }, out data); +// myWrite(StreamOpCode.create, data); +// myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// Assert.AreEqual(1, ops.Length); +// Assert.AreEqual(StreamOpCode.create, ops[0]); +// Assert.AreEqual(1, rows.Length); +// receivedData = rows.GetValue(0) as IBlueRowCollection[]; +// Assert.AreEqual(1, receivedData.Length); - BlueDataUtility.computeDifferences(receivedData[0], myTable, out del, out add); - Assert.AreEqual(0, del.Count); - Assert.AreEqual(0, add.Count); +// BlueDataUtility.computeDifferences(receivedData[0], myTable, out del, out add); +// Assert.AreEqual(0, del.Count); +// Assert.AreEqual(0, add.Count); - //single add - r = myGetRow(id); - BlueTable temp = new BlueTable(mySchema); - myTable.addRow(r); - temp.addRow(r); - mySer.serialize(StreamOpCode.add, new IBlueRowCollection[] { temp }, out data); - myWrite(StreamOpCode.add, data); - myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - Assert.AreEqual(1, ops.Length); - Assert.AreEqual(StreamOpCode.add, ops[0]); - Assert.AreEqual(1, rows.Length); - receivedData = rows.GetValue(0) as IBlueRowCollection[]; - Assert.AreEqual(1, receivedData.Length); - BlueDataUtility.computeDifferences(receivedData[0], temp, out del, out add); - Assert.AreEqual(0, del.Count); - Assert.AreEqual(0, add.Count); +// //single add +// r = myGetRow(id); +// BlueTable temp = new BlueTable(mySchema); +// myTable.addRow(r); +// temp.addRow(r); +// mySer.serialize(StreamOpCode.add, new IBlueRowCollection[] { temp }, out data); +// myWrite(StreamOpCode.add, data); +// myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// Assert.AreEqual(1, ops.Length); +// Assert.AreEqual(StreamOpCode.add, ops[0]); +// Assert.AreEqual(1, rows.Length); +// receivedData = rows.GetValue(0) as IBlueRowCollection[]; +// Assert.AreEqual(1, receivedData.Length); +// BlueDataUtility.computeDifferences(receivedData[0], temp, out del, out add); +// Assert.AreEqual(0, del.Count); +// Assert.AreEqual(0, add.Count); - //single delete - r = myTable[0]; //delete row with id 0 - temp = new BlueTable(mySchema); - myTable.deleteRow(0); - temp.addRow(r); - mySer.serialize(StreamOpCode.remove, new IBlueRowCollection[] { temp }, out data); - myWrite(StreamOpCode.remove, data); - myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - Assert.AreEqual(1, ops.Length); - Assert.AreEqual(StreamOpCode.remove, ops[0]); - Assert.AreEqual(1, rows.Length); - receivedData = rows.GetValue(0) as IBlueRowCollection[]; - Assert.AreEqual(1, receivedData.Length); - BlueDataUtility.computeDifferences(receivedData[0], temp, out del, out add); - Assert.AreEqual(0, del.Count); - Assert.AreEqual(0, add.Count); +// //single delete +// r = myTable[0]; //delete row with id 0 +// temp = new BlueTable(mySchema); +// myTable.deleteRow(0); +// temp.addRow(r); +// mySer.serialize(StreamOpCode.remove, new IBlueRowCollection[] { temp }, out data); +// myWrite(StreamOpCode.remove, data); +// myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// Assert.AreEqual(1, ops.Length); +// Assert.AreEqual(StreamOpCode.remove, ops[0]); +// Assert.AreEqual(1, rows.Length); +// receivedData = rows.GetValue(0) as IBlueRowCollection[]; +// Assert.AreEqual(1, receivedData.Length); +// BlueDataUtility.computeDifferences(receivedData[0], temp, out del, out add); +// Assert.AreEqual(0, del.Count); +// Assert.AreEqual(0, add.Count); - //batch deletes and adds - //0 was removed earlier, so lets delete from 1 to 24 first, and then add 101 to 124 - BlueTable delRows = new BlueTable(mySchema), addRows = new BlueTable(mySchema); - for (int i = 1; i < 25; i++) { - delRows.addRow(myTable[i]); - myTable.deleteRow(i); - } - for (id = 101; id < 125; id++) { - r = myGetRow(id); - addRows.addRow(r); - myTable.addRow(r); - } - for (int i = 25; i < 125; i++) - Assert.AreEqual(true, myTable.containsID(i)); - Assert.AreEqual(100, myTable.Count); +// //batch deletes and adds +// //0 was removed earlier, so lets delete from 1 to 24 first, and then add 101 to 124 +// BlueTable delRows = new BlueTable(mySchema), addRows = new BlueTable(mySchema); +// for (int i = 1; i < 25; i++) { +// delRows.addRow(myTable[i]); +// myTable.deleteRow(i); +// } +// for (id = 101; id < 125; id++) { +// r = myGetRow(id); +// addRows.addRow(r); +// myTable.addRow(r); +// } +// for (int i = 25; i < 125; i++) +// Assert.AreEqual(true, myTable.containsID(i)); +// Assert.AreEqual(100, myTable.Count); - mySer.serialize(StreamOpCode.multipleRemoveAdd, new IBlueRowCollection[] { delRows, addRows }, out data); - myWrite(StreamOpCode.multipleRemoveAdd, data); - myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - Assert.AreEqual(1, ops.Length); - Assert.AreEqual(StreamOpCode.multipleRemoveAdd, ops[0]); - Assert.AreEqual(1, rows.Length); - receivedData = rows.GetValue(0) as IBlueRowCollection[]; - Assert.AreEqual(2, receivedData.Length); - BlueDataUtility.computeDifferences(receivedData[0], delRows, out del, out add); - Assert.AreEqual(0, del.Count); - Assert.AreEqual(0, add.Count); - BlueDataUtility.computeDifferences(receivedData[1], addRows, out del, out add); - Assert.AreEqual(0, del.Count); - Assert.AreEqual(0, add.Count); +// mySer.serialize(StreamOpCode.multipleRemoveAdd, new IBlueRowCollection[] { delRows, addRows }, out data); +// myWrite(StreamOpCode.multipleRemoveAdd, data); +// myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// Assert.AreEqual(1, ops.Length); +// Assert.AreEqual(StreamOpCode.multipleRemoveAdd, ops[0]); +// Assert.AreEqual(1, rows.Length); +// receivedData = rows.GetValue(0) as IBlueRowCollection[]; +// Assert.AreEqual(2, receivedData.Length); +// BlueDataUtility.computeDifferences(receivedData[0], delRows, out del, out add); +// Assert.AreEqual(0, del.Count); +// Assert.AreEqual(0, add.Count); +// BlueDataUtility.computeDifferences(receivedData[1], addRows, out del, out add); +// Assert.AreEqual(0, del.Count); +// Assert.AreEqual(0, add.Count); - //pure changes only - //change the first 25, 25-49 - BlueTable changedRows = new BlueTable(mySchema); - for (int i = 25; i < 50; i++) { - MutableBlueRow mr = new MutableBlueRow(myTable[i]); - mr.setValue(4, Byte.MaxValue); - myTable.changeRow(mr); - changedRows.addRow(mr); - } - mySer.serialize(StreamOpCode.multipleChange, new IBlueRowCollection[] { changedRows }, out data); - myWrite(StreamOpCode.multipleChange, data); - myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - Assert.AreEqual(1, ops.Length); - Assert.AreEqual(StreamOpCode.multipleChange, ops[0]); - Assert.AreEqual(1, rows.Length); - receivedData = rows.GetValue(0) as IBlueRowCollection[]; - Assert.AreEqual(1, receivedData.Length); - BlueDataUtility.computeDifferences(receivedData[0], changedRows, out del, out add); - Assert.AreEqual(0, del.Count); - Assert.AreEqual(0, add.Count); +// //pure changes only +// //change the first 25, 25-49 +// BlueTable changedRows = new BlueTable(mySchema); +// for (int i = 25; i < 50; i++) { +// MutableBlueRow mr = new MutableBlueRow(myTable[i]); +// mr.setValue(4, Byte.MaxValue); +// myTable.changeRow(mr); +// changedRows.addRow(mr); +// } +// mySer.serialize(StreamOpCode.multipleChange, new IBlueRowCollection[] { changedRows }, out data); +// myWrite(StreamOpCode.multipleChange, data); +// myPubsubDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// myClientDeser.deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// Assert.AreEqual(1, ops.Length); +// Assert.AreEqual(StreamOpCode.multipleChange, ops[0]); +// Assert.AreEqual(1, rows.Length); +// receivedData = rows.GetValue(0) as IBlueRowCollection[]; +// Assert.AreEqual(1, receivedData.Length); +// BlueDataUtility.computeDifferences(receivedData[0], changedRows, out del, out add); +// Assert.AreEqual(0, del.Count); +// Assert.AreEqual(0, add.Count); - //final test - data = myPubsubDeser.getState(); - new ClientDeserializationController().deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); - Assert.AreEqual(1, ops.Length); - Assert.AreEqual(StreamOpCode.create, ops[0]); - Assert.AreEqual(1, rows.Length); - receivedData = rows.GetValue(0) as IBlueRowCollection[]; - Assert.AreEqual(1, receivedData.Length); - BlueDataUtility.computeDifferences(receivedData[0], myTable, out del, out add); - Assert.AreEqual(0, del.Count); - Assert.AreEqual(0, add.Count); +// //final test +// data = myPubsubDeser.getState(); +// new ClientDeserializationController().deserialize(new Stream[] { new MemoryStream(data) }, out ops, out rows); +// Assert.AreEqual(1, ops.Length); +// Assert.AreEqual(StreamOpCode.create, ops[0]); +// Assert.AreEqual(1, rows.Length); +// receivedData = rows.GetValue(0) as IBlueRowCollection[]; +// Assert.AreEqual(1, receivedData.Length); +// BlueDataUtility.computeDifferences(receivedData[0], myTable, out del, out add); +// Assert.AreEqual(0, del.Count); +// Assert.AreEqual(0, add.Count); - } +// } - private IBlueRow myGetRow(int id) { - return new BlueRow(mySchema, // the day pp fixed this test. - id, id + 10, id * 3.0, new DateTime(2008, 6, 4, 0, 0, 0, DateTimeKind.Unspecified), Convert.ToByte(id)); - } +// private IBlueRow myGetRow(int id) { +// return new BlueRow(mySchema, // the day pp fixed this test. +// id, id + 10, id * 3.0, new DateTime(2008, 6, 4, 0, 0, 0, DateTimeKind.Unspecified), Convert.ToByte(id)); +// } - private void myWrite(byte op, byte[] data) { - string s = ""; - if (op == StreamOpCode.add) - s = "add one row"; - else if (op == StreamOpCode.change) - s = "change one row"; - else if (op == StreamOpCode.create) - s = "create"; - else if (op == StreamOpCode.multipleChange) - s = "multiple change"; - else if (op == StreamOpCode.multipleRemoveAdd) - s = "multiple add remove"; - else if (op == StreamOpCode.remove) - s = "remove one row"; - Console.WriteLine("yes, here , op = {0}, size = {1}", s, data.Length); - } - } -} +// private void myWrite(byte op, byte[] data) { +// string s = ""; +// if (op == StreamOpCode.add) +// s = "add one row"; +// else if (op == StreamOpCode.change) +// s = "change one row"; +// else if (op == StreamOpCode.create) +// s = "create"; +// else if (op == StreamOpCode.multipleChange) +// s = "multiple change"; +// else if (op == StreamOpCode.multipleRemoveAdd) +// s = "multiple add remove"; +// else if (op == StreamOpCode.remove) +// s = "remove one row"; +// //Console.WriteLine("yes, here , op = {0}, size = {1}", s, data.Length); +// } +// } +// } diff --git a/src/DataStreamSuite/PubSub/Client/Communication/IPubSubServerConnection.cs b/src/DataStreamSuite/PubSub/Client/Communication/IPubSubServerConnection.cs index 1ec1ab957..223c2ca67 100644 --- a/src/DataStreamSuite/PubSub/Client/Communication/IPubSubServerConnection.cs +++ b/src/DataStreamSuite/PubSub/Client/Communication/IPubSubServerConnection.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Text; using System.IO; using BCG.Utilities.General; +using bts; namespace BCG { /// @@ -35,6 +36,7 @@ namespace BCG { // /// void send(Stream str); void send(PubSubMessage msg); + void send(bts.PubSubClientMessage ps_msg); void send_with_confirmation(PubSubMessage msg, ref string confId); /// /// Returns with 0 or more elements, iff the timeout diff --git a/src/DataStreamSuite/PubSub/Client/Communication/ManagedTCP/PubSubServerManagedTCPConnection.cs b/src/DataStreamSuite/PubSub/Client/Communication/ManagedTCP/PubSubServerManagedTCPConnection.cs index f9d2cb31e..d6cfec23e 100644 --- a/src/DataStreamSuite/PubSub/Client/Communication/ManagedTCP/PubSubServerManagedTCPConnection.cs +++ b/src/DataStreamSuite/PubSub/Client/Communication/ManagedTCP/PubSubServerManagedTCPConnection.cs @@ -77,6 +77,13 @@ namespace BCG { } } + public void send(bts.PubSubClientMessage ps_msg) { + MemoryStream ms = new MemoryStream(); + ps_msg.serialize_into_str(ms); + var msg_bytes = StreamUtilityMethods.getBytesFromStream(ms); + send(msg_bytes); + } + public void send(Stream str) { BinaryReader br = new BinaryReader(str); send(br.ReadBytes(Convert.ToInt32(str.Length - str.Position))); diff --git a/src/DataStreamSuite/PubSub/Client/MetaData/PubSubClientMessage.cs b/src/DataStreamSuite/PubSub/Client/MetaData/PubSubClientMessage.cs new file mode 100644 index 000000000..69b9767f6 --- /dev/null +++ b/src/DataStreamSuite/PubSub/Client/MetaData/PubSubClientMessage.cs @@ -0,0 +1,177 @@ +using System; +using System.IO; + +namespace bts { + using BCG; + + using System.Collections; + using System.IO; + + public interface IPubSubMessage { + void serialize_into_str(Stream str); + void consruct_deserialize(Stream str); + } + public class SubscribeMsg : IPubSubMessage { + public string connection; + public string subscribing_app; + public string[] tags; + public void serialize_into_str(Stream str) { + BinaryWriter bw = new BinaryWriter(str); + bw.Write(connection); + bw.Write(subscribing_app); + bw.Write(tags.Length); + foreach (var t in tags) + bw.Write(t); + } + + public void consruct_deserialize(Stream str) { + BinaryReader br = new BinaryReader(str); + this.connection = br.ReadString(); + this.subscribing_app = br.ReadString(); + var n_tags = br.ReadInt32(); + tags = new string[n_tags]; + for (var i = 0; i < n_tags; i++) + tags[i] = br.ReadString(); + } + public override string ToString() { + return $"connection: {connection} subscribing_app: {subscribing_app} tags: {tags.Length}"; + } + } + + public class UnsubscribeMsg : SubscribeMsg { + } + + public class TransactionMsg : IPubSubMessage { + uint n_msgs; + public void serialize_into_str(Stream str) { + BinaryWriter bw = new BinaryWriter(str); + bw.Write(n_msgs); + } + public void consruct_deserialize(Stream str) { + BinaryReader br = new BinaryReader(str); + n_msgs = br.ReadUInt32(); + } + } + + public class PublishMsg : IPubSubMessage { + public string connection; + public string publishing_app; + public string tag; + public string tag_type; + public bool is_compressed; + // this is the size that of the msg, regarless of it being serialized or not + public long publish_time_epoch_ms; + public byte[] data_to_publish; + + public void serialize_into_str(Stream str) { + BinaryWriter bw = new BinaryWriter(str); + bw.Write(connection); + bw.Write(publishing_app); + bw.Write(tag); + bw.Write(tag_type); + bw.Write(is_compressed); + bw.Write(publish_time_epoch_ms); + var sz = data_to_publish.Length; + bw.Write(sz); + bw.Write(data_to_publish); + } + public void consruct_deserialize(Stream str) { + BinaryReader br = new BinaryReader(str); + connection = br.ReadString(); + publishing_app = br.ReadString(); + tag = br.ReadString(); + tag_type = br.ReadString(); + is_compressed = br.ReadBoolean(); + publish_time_epoch_ms = br.ReadInt64(); + var size = br.ReadInt32(); + data_to_publish = br.ReadBytes(size); + } + + } + public enum PubSubMessageType { + SUBSCRIIBE = 0, + UNSUBSCRIIBE, + TRANSACTION, + PUBLISH + } + + public class PubSubClientMessage : IPubSubMessage { + public PubSubMessageType msg_type; + // only one of these wil be non null + public SubscribeMsg sub_msg; + public UnsubscribeMsg unsub_msg; + public TransactionMsg transaction_msg; + public PublishMsg pub_msg; + + public void serialize_into_str(Stream str) { + BinaryWriter bw = new BinaryWriter(str); + bw.Write((int)msg_type); + switch (msg_type) { + case PubSubMessageType.SUBSCRIIBE: + sub_msg.serialize_into_str(str); + break; + case PubSubMessageType.UNSUBSCRIIBE: + unsub_msg.serialize_into_str(str); + break; + case PubSubMessageType.TRANSACTION: + transaction_msg.serialize_into_str(str); + break; + case PubSubMessageType.PUBLISH: + pub_msg.serialize_into_str(str); + break; + } + } + + public void consruct_deserialize(Stream str) { + BinaryReader br = new BinaryReader(str); + int type = br.ReadInt32(); + var msg_type = (PubSubMessageType)type; + switch (msg_type) { + case PubSubMessageType.SUBSCRIIBE: + sub_msg = new SubscribeMsg(); + sub_msg.consruct_deserialize(str); + break; + case PubSubMessageType.UNSUBSCRIIBE: + unsub_msg = new UnsubscribeMsg(); + unsub_msg.consruct_deserialize(str); + break; + case PubSubMessageType.TRANSACTION: + transaction_msg = new TransactionMsg(); + transaction_msg.consruct_deserialize(str); + break; + case PubSubMessageType.PUBLISH: + pub_msg = new PublishMsg(); + pub_msg.consruct_deserialize(str); + break; + } + } + + + } + + // + public class PubSubServerMessage : IPubSubMessage { + public string tag; + public string tag_type; + public byte[] data; + public void serialize_into_str(Stream str) { + BinaryWriter bw = new BinaryWriter(str); + bw.Write(tag); + bw.Write(tag_type); + bw.Write(data.Length); + bw.Write(data); + } + public void consruct_deserialize(Stream str) { + BinaryReader br = new BinaryReader(str); + tag = br.ReadString(); + tag_type = br.ReadString(); + var data_sz = br.ReadInt32(); + data = br.ReadBytes(data_sz); + } + + } + +} + + + diff --git a/src/DataStreamSuite/PubSub/Server/Communication/IPubsubMessageHubBase.cs b/src/DataStreamSuite/PubSub/Server/Communication/IPubsubMessageHubBase.cs index 8e7bfc15b..6e1ed19ff 100644 --- a/src/DataStreamSuite/PubSub/Server/Communication/IPubsubMessageHubBase.cs +++ b/src/DataStreamSuite/PubSub/Server/Communication/IPubsubMessageHubBase.cs @@ -45,7 +45,8 @@ namespace BCG { /// /// Gets the updates and the source of the data /// from the clients. Returns either if timeout - /// expires or maxElements have been fetched. + /// expires or maxElements have been fetched. The string + /// in the pair is the client url /// /// /// @@ -56,6 +57,7 @@ namespace BCG { /// /// bool send(string receiver, byte[] data); + bool send(string receiver, bts.PubSubServerMessage ps_msg); /// /// sends the data stored in the current position in the Stream. /// diff --git a/src/DataStreamSuite/PubSub/Server/Communication/ManagedTCP/ManagedTCPMessageHub.cs b/src/DataStreamSuite/PubSub/Server/Communication/ManagedTCP/ManagedTCPMessageHub.cs index b2e2518d9..51aea83c7 100644 --- a/src/DataStreamSuite/PubSub/Server/Communication/ManagedTCP/ManagedTCPMessageHub.cs +++ b/src/DataStreamSuite/PubSub/Server/Communication/ManagedTCP/ManagedTCPMessageHub.cs @@ -115,6 +115,12 @@ namespace BCG { return send(receiver, br.ReadBytes(Convert.ToInt32(str.Length - str.Position))); } + public bool send(string receiver, bts.PubSubServerMessage ps_msg) { + MemoryStream str = new MemoryStream(); + ps_msg.serialize_into_str(str); + return send(receiver, str); + } + #endregion #region IWorker Members diff --git a/src/DataStreamSuite/PubSub/Server/Communication/ServerMessageHub.cs b/src/DataStreamSuite/PubSub/Server/Communication/ServerMessageHub.cs index af1301f19..2bd27267f 100644 --- a/src/DataStreamSuite/PubSub/Server/Communication/ServerMessageHub.cs +++ b/src/DataStreamSuite/PubSub/Server/Communication/ServerMessageHub.cs @@ -102,6 +102,12 @@ namespace BCG { return false; } + public bool send(string receiver, bts.PubSubServerMessage ps_msg) { + MemoryStream str = new MemoryStream(); + ps_msg.serialize_into_str(str); + return send(receiver, str); + } + #endregion #region IWorker Members diff --git a/src/DataStreamSuite/PubSub/Server/PubSubMessageReactor.cs b/src/DataStreamSuite/PubSub/Server/PubSubMessageReactor.cs index 749c3437b..4031b6ee3 100644 --- a/src/DataStreamSuite/PubSub/Server/PubSubMessageReactor.cs +++ b/src/DataStreamSuite/PubSub/Server/PubSubMessageReactor.cs @@ -1,53 +1,47 @@ using System; -//using System.Messaging; -using System.Collections; -using System.Net; -using System.Net.Sockets; using System.IO; using System.Text; using System.Threading; -using System.Reflection; -using System.Runtime.Serialization.Formatters.Binary; -using System.Xml.Serialization; using System.Collections.Generic; - -//using BCG.Utilities; -//using BCG.Utilities.General; using mbts; using mbts.spark; +using bts; namespace BCG { + // This is the main PubSub Server class where it all starts. Its constructed and start is called and thats it. + // The only outward facing members of this class is start + // It has an IPubsubMessageHub, that it gets messages from, and updates the PubSubState (which really is all the pubsub server state) public class PubSubMessageReactor { - private ServerMessageHub myMessageHub; + private IPubsubMessageHub _msg_hub; private delegate void MyMsgHandler(string sender, Stream msg, MetaData m); private Dictionary myOperationToHandler = new Dictionary(); - private Thread myReceivingProcThread = null; - private PubSubState myState = new PubSubState(); + private Thread _msg_polling_thread = null; + private PubSubState _state = new PubSubState(); private bool myStop = false; private MasterWorker myMasterWorker = MasterWorker.getInstance(false); private double myProcessingWarningThreshold = Convert.ToDouble(PubSub3Config.instance.PS3_MessageProcessingWarningThreshold); private HighPerformanceTimer myTimer = new HighPerformanceTimer(); - public delegate void SingleTagTimeSliceDelegate(string tag, double processingTimeSeconds); - public SingleTagTimeSliceDelegate onSingleTagPub; + private delegate void SingleTagTimeSliceDelegate(string tag, double processingTimeSeconds); + private SingleTagTimeSliceDelegate onSingleTagPub; private HighPerformanceTimer mySingleTagTimeSliceTimer = new HighPerformanceTimer(); //this thing keeps track of whether a given tag is compressed or not. It is used for logging messages. - /* 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) { + /* This delegate allows pubsub components to be notified when the identity ofe the pubsub is known*/ + private delegate void IdentityFoundDelegate(string identity, bool isRoot); + private event IdentityFoundDelegate onIdentityFound; + private void fireIdentityFound(string identity, bool isRoot) { if (onIdentityFound != null) onIdentityFound(identity, isRoot); } - public Dictionary myTagCompressionState = new Dictionary(); + private 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() : 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)); @@ -56,17 +50,18 @@ namespace BCG { bts.Log.Gen.info("PubSubMessageReactor.cons System Initialized"); - myReceivingProcThread = new Thread(new ThreadStart(myReceivingThreadProc)); - myMessageHub = ServerMessageHub.instance; - myMessageHub.registerConnectionCallback(new PubSubServerConnectionStatusChange(myHandleConnections)); + _msg_polling_thread = new Thread(new ThreadStart(_polling_thread_func)); + _msg_polling_thread.Priority = ThreadPriority.AboveNormal; + _msg_hub = ServerMessageHub.instance; + _msg_hub.registerConnectionCallback(new PubSubServerConnectionStatusChange(myHandleConnections)); } #region message handlers - public PubSubState state { - get { return myState; } + private PubSubState state { + get { return _state; } //this variable is read only } @@ -81,16 +76,16 @@ namespace BCG { meta_data.copyTo(pub); pub.connection = sender; pub.warnIfLatencyExceedsThreshold(); - var subs_for_tag = myState.getSubscriberConnectionsForTag(pub.tag); + var subs_for_tag = _state.getSubscriberConnectionsForTag(pub.tag); bts.Log.Gen.info($"PubSubMessageReactor.myHandlePub {subs_for_tag.Count} subs for tag: {pub.tag}"); ///for all the subscribers, sends the messages over straightaway - foreach (string address in myState.getSubscriberConnectionsForTag(pub.tag)) { + foreach (string address in _state.getSubscriberConnectionsForTag(pub.tag)) { ///the position is adjusted to zero, so as to include ///the meta data as part of the message 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); + _msg_hub.send(address, msg_str); } //reset the position of the message so we can decompress it appropriately @@ -137,7 +132,7 @@ namespace BCG { ///updating state msg_str.Position = 0; msg_str.Position += meta_data.size(); - myState.updatePubData(pub, msg_str); + _state.updatePubData(pub, msg_str); mySingleTagTimeSliceTimer.stop(); double thisTagProcessingTime = mySingleTagTimeSliceTimer.lastIntervalTime; if (onSingleTagPub != null) @@ -153,13 +148,13 @@ namespace BCG { sub.connection = sender; ///update the state - myState.sub(sub); + _state.sub(sub); ///to all these new subscriber s, send the existing data foreach (string tag in sub.tags) { - byte[] data = myState.getContent(tag); + byte[] data = _state.getContent(tag); //ie data has been published once if (data != null) { - string tagType = myState.getTagType(tag); + string tagType = _state.getTagType(tag); ///passing "" as the 4th arg, as PubMeta is used both by the ///publisher to publish data to the server (where the publisher ///indicates its identification as the 4th arg) as well as by @@ -185,7 +180,7 @@ namespace BCG { toSend.Write(realContent.ToArray(), 0, (int)realContent.Length); toSend.Position = 0; - myMessageHub.send(sub.connection, toSend); + _msg_hub.send(sub.connection, toSend); } } } @@ -195,7 +190,7 @@ namespace BCG { m.copyTo(unsub); if (unsub.connection.Trim().Length == 0) unsub.connection = sender; - myState.unsub(unsub); + _state.unsub(unsub); } private void myHandleTransaction(string sender, Stream msg, MetaData md) { @@ -234,24 +229,24 @@ namespace BCG { } - myState.updatePubData(pub, new MemoryStream(tagData)); + _state.updatePubData(pub, new MemoryStream(tagData)); tagToMessages.Add(pub.tag, tagData); } ///this gives subscriber->tag* - Dictionary> subscriberToTags = myState.getSubscriberConnectionsForTags(tagToMessages.Keys); + Dictionary> subscriberToTags = _state.getSubscriberConnectionsForTags(tagToMessages.Keys); 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) { byte[] tagData = tagToMessages[tag]; - PubMetaData pub = new PubMetaData(myState.getTagType(tag), tag, tagData.Length, "", ""); + PubMetaData pub = new PubMetaData(_state.getTagType(tag), tag, tagData.Length, "", ""); new MetaData(pub).save(subStream); subStream.Write(tagData, 0, tagData.Length); } subStream.Position = 0; //myState.send(kvp.Key, subStream); - myMessageHub.send(kvp.Key, subStream); + _msg_hub.send(kvp.Key, subStream); } mySingleTagTimeSliceTimer.stop(); @@ -287,69 +282,142 @@ namespace BCG { ///significance until they subscribe, in which case an entry ///will be made if (!connected) - myState.removeConnection(client); + _state.removeConnection(client); } - public void stop() { + private void stop() { myStop = true; } public void start() { - myReceivingProcThread.Start(); + _msg_polling_thread.Start(); } /// - /// loops around and reads messages from the messageReceiver. calls processMsg - /// passing in the IClientMessage. also logs stuff about the message. + /// This is the main PubSubServer thread. It loops around and read messages from + /// the IPubsubMessageHub. It then deserializes the messages and calls the approrpriate + /// hanlder /// - private void myReceivingThreadProc() { - TimeSpan receiveTimeout = new TimeSpan(0, 0, 0, 0, 2500); - myMessageHub.activate(); + private void _polling_thread_func() { + TimeSpan poll_timeout = new TimeSpan(0, 0, 0, 0, 2500); + _msg_hub.activate(); //once you've activated the message hub, you're OK to create the watchers //(some of the watchers depend upon the message hub) // TODO // PubSubComponentFactory.buildPubSubWatchers(this); - string sender; - Stream msg; - MetaData meta; - while (!myStop) { - sender = null; - msg = null; - meta = null; + // string sender; + // Stream msg; + // MetaData meta; + while (true) { + // sender = null; + // msg = null; + // meta = null; try { - List> receivedData = myMessageHub.getUpdates(receiveTimeout, 1); - 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) { - string warningMsg = String.Format("processing metadata {0} took {1} msecs", meta, myTimer.lastIntervalTime); - //BlueEventLog.logEvent(warningMsg, PS3LogLevels.performance); - } + List> receivedData = _msg_hub.getUpdates(poll_timeout, 1); + foreach (var kv in receivedData) { + _handle_client_msg(kv.first, kv.second); } + // 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) { + // string warningMsg = String.Format("processing metadata {0} took {1} msecs", meta, myTimer.lastIntervalTime); + // //BlueEventLog.logEvent(warningMsg, PS3LogLevels.performance); + // } + // } myMasterWorker.doWork(); - } 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 : " + - "\n" + - "sender = {0}" + - "\n" + - "meta data = {1}" + - "\n" + - "stack trace:\n" + - e.StackTrace, sender == null ? "Unknown" : sender, - meta == null ? "Unknown" : meta.ToString()); - //BlueEventLog.logEvent(errMsg, BlueEventLevel.Error); - //BlueEventLog.logEvent(errMsg, BlueEventLog2Level.Console); - if (e is OutOfMemoryException) - throw e; + } catch (Exception ex) { + bts.Log.Gen.error($"PubSubMessage>reactor._polling_thread_func ex: {ex}"); + if (ex is OutOfMemoryException) + throw ex; } } } + + private void _handle_client_msg(string sender, byte[] msg) { + // TODO: reduce object creation, C# has an ObjectPool + PubSubClientMessage ps_client_msg = new PubSubClientMessage(); + var str = new MemoryStream(msg); + ps_client_msg.consruct_deserialize(str); + switch (ps_client_msg.msg_type) { + case PubSubMessageType.SUBSCRIIBE: + _handle_sub(sender, ps_client_msg.sub_msg); + break; + case PubSubMessageType.UNSUBSCRIIBE: + _handle_unsub(sender, ps_client_msg.unsub_msg); + break; + case PubSubMessageType.TRANSACTION: + _handle_transaction(sender, ps_client_msg.transaction_msg); + break; + case PubSubMessageType.PUBLISH: + _handle_pub(sender, ps_client_msg.pub_msg); + break; + } + } + + private void _handle_sub(string sender, SubscribeMsg sub_msg) { + bts.Log.Gen.info($"PubSubMessageReactor._handle_sub sender: {sender} sub_msg: {sub_msg}"); + // SubMetaData sub = new SubMetaData(); + // m.copyTo(sub); + // sub.connection = sender; + + ///update the state + _state.sub(sub_msg); // state keeps the list of all subscribers + ///to all these new subscriber s, send the existing data + foreach (string tag in sub_msg.tags) { + byte[] data = _state.getContent(tag); + //ie data has been published once + if (data != null) { + string tagType = _state.getTagType(tag); + var msg_to_send = new PubSubServerMessage() { + tag = tag, + tag_type = tagType, + data = data + }; + _msg_hub.send(sub_msg.connection, msg_to_send); + return; + } + } + + } + private void _handle_pub(string sender, PublishMsg pub_msg) { + bts.Log.assert(!pub_msg.is_compressed); + bts.Log.Gen.info($"PubSubMessageReactor._handle_pub sender: {sender} pub_msg: {pub_msg}"); + // this is where pubsub's data state is updated + _state.update_pub_data(pub_msg); + var sub_connections_for_tag = _state.getSubscriberConnectionsForTag(pub_msg.tag); + bts.Log.Gen.info($"PubSubMessageReactor._handle_pub {sub_connections_for_tag.Count} subs for tag: {pub_msg.tag}"); + bts.PubSubServerMessage msg_to_send = new PubSubServerMessage() { + tag = pub_msg.tag, + tag_type = pub_msg.tag_type, + data = pub_msg.data_to_publish + }; + + ///for all the subscribers, sends the messages over straightaway + foreach (string client_url in sub_connections_for_tag) { + bts.Log.Gen.info($"PubSubMessageReactor._handle_pub sending tag: {pub_msg.tag} to {client_url}"); + _msg_hub.send(client_url, msg_to_send); + } + } + + private void _handle_transaction(string sender, TransactionMsg transaction_msg) { + + } + + private void _handle_unsub(string sender, UnsubscribeMsg ubnsub_msg) { + // TODO: check ubnsub_msg.connection + + // UnSubMetaData unsub = new UnSubMetaData(); + // m.copyTo(unsub); + // if (unsub.connection.Trim().Length == 0) + // unsub.connection = sender; + _state.unsub(ubnsub_msg); + + } } } diff --git a/src/DataStreamSuite/PubSub/Server/PubSubState.cs b/src/DataStreamSuite/PubSub/Server/PubSubState.cs index d24360efd..025c8e3b9 100644 --- a/src/DataStreamSuite/PubSub/Server/PubSubState.cs +++ b/src/DataStreamSuite/PubSub/Server/PubSubState.cs @@ -22,7 +22,7 @@ namespace BCG { public class PubSubState { public delegate void PubSubStateSingleTagChangeDelegate(PubSubSingleTagStateEvent theEvent); - public event PubSubStateSingleTagChangeDelegate onSingleTagChange; + private event PubSubStateSingleTagChangeDelegate onSingleTagChange; public delegate void PubSubStateChangeDelegate(string[] tags); public event PubSubStateChangeDelegate onTagMapChanged; public delegate void PubSubStatsDelegate(string tag, int size); @@ -61,6 +61,10 @@ namespace BCG { onTagMapChanged(sub.tags); } + public void sub(bts.SubscribeMsg sub_msg) { + // TODO + } + public void unsub(UnSubMetaData unsub) { foreach (string tag in unsub.tags) { if (myTagToPubsubMap.ContainsKey(tag)) { @@ -79,6 +83,10 @@ namespace BCG { onTagMapChanged(unsub.tags); } + public void unsub(bts.UnsubscribeMsg ubnsub_msg) { + + } + public void removeConnection(string connection) { List tagsEffected = new List(); foreach (KeyValuePair p in myTagToPubsubMap) { @@ -144,6 +152,8 @@ namespace BCG { } + public void update_pub_data(bts.PublishMsg pub_msg) { } + #endregion public ICollection getSubscriberConnectionsForTag(string tag) { diff --git a/src/DataStreamSuite/PubSub/Server/SingleTagPubSubMap.cs b/src/DataStreamSuite/PubSub/Server/SingleTagPubSubMap.cs index d9c30ad8d..755d9ee6f 100644 --- a/src/DataStreamSuite/PubSub/Server/SingleTagPubSubMap.cs +++ b/src/DataStreamSuite/PubSub/Server/SingleTagPubSubMap.cs @@ -93,6 +93,11 @@ namespace BCG { } } + public bool on_sub(bts.SubscribeMsg sub_msg) { + // TODO + return true; + } + /// /// Called by PubsubState when a subscriber unsubscribes to this tag. /// Returns a true when a subscriber exists, else logs a warning and diff --git a/src/DataStreamSuite/PubSub/documentation/readme.txt b/src/DataStreamSuite/PubSub/documentation/readme.txt index 31abc2afb..5f1a6ae3c 100644 --- a/src/DataStreamSuite/PubSub/documentation/readme.txt +++ b/src/DataStreamSuite/PubSub/documentation/readme.txt @@ -14,3 +14,26 @@ All communication to PubSubServer happens using this. It has 3 main types of cal The only implementation of the above is PubSubServerManagedTCPConnection (there used to be an MSMQ one and another wrapped around native code - but neither exists anymore) +PubSubMessages: +PubSubClientMessage is the only messages thats sent from client to pubsubserver. Its serialized on the +client and sent over to the pubsubserver, where uits received ad deserialized + +PubSubServer: +PubSubMessageReactor (top level, called from main) +ServerMessageHub : IPubsubMessageHub (just a wrapper so multiple ) +ManagedTCPMessageHub : IPubsubMessageHub (this is what handles each ITCPConnection for eahc connection) + + +Streams: +PubTableBroker allows publishing of streams through createTable, addRow, deleteRow, changeRow, makeBatchChanges -> +PubTablePublisher:IPubTablePublisher per tag (addRow, deleteRow, changeRow, createTable, batchRemoveAdd) +PubTablePublisher has BlueDataSerializationController:IBlueDataSerializer to serialize the rows to byte[] +BlueDataSerializationController uses a IBlueDataSerializer, which is specialized for the tag (using UniversalSerializer for now) + +IBlueDataSerializer has just one function +void serialize (byte op, IBlueRowCollection[] rows, out byte[] serializedData); +the second arg is IBlueRowCollection[] because in case of op = StreamOpCode.multipleRemoveAdd, it has multiple IBlueRowCollection for rem and add +(BlueDataSerializer.serialize's comment has the serialization layout) + +For each serializer we have 2 matching deserializers, IPubsubDeserializer (for PubSubservr) and IClientDeserializer (for clients subscribing to streams) +For UniversalSerializer, we have PubsubUniversalDeserializer and ClientUniversalDeserializer \ No newline at end of file