Files
spark/src/DataStreamSuite/PubSub/SingleServerSubscriberCore.cs
T

157 lines
6.6 KiB
C#

using bts;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Runtime.InteropServices;
namespace BCG {
/// <summary>
/// Deals with the subscriptions (and getting data) from one single
/// pubsub server. Theres no sharing of conenctions
/// from this point. Every new instance of SingleServerSubscriberCore
/// will open its new dedicated connection to the serverURL that
/// its concerned with (passed as a conctructor arg).
/// </summary>
internal interface ISingleServerSubscriberCore : IDisposable {
IEnumerable<PubSubServerMessage> get_updates(TimeSpan timeout);
event PubSubConnectionChange onPubSubConnectionChange;
void subscribe(params string[] tags);
void unsubscribe(params string[] tags);
}
internal class SingleServerSubscriberCore : IDisposable, ISingleServerSubscriberCore {
private readonly IPubSubServerConnection _connection;
private SyncQueue<byte[]> _in_data_queue = new SyncQueue<byte[]>();
private HashSet<string> _tags = new HashSet<string>();
public event PubSubConnectionChange onPubSubConnectionChange;
public SingleServerSubscriberCore(RemoteConnectionInfo server_rci, PubSubServerConnectionFactory connection_factory) {
bts.Log.Gen.info($"SingleServerSubscriberCore constructed for server_url: {server_rci}");
_connection = connection_factory.get_connection(server_rci);
_connection.register_connection_callback(new PubSubServerConnectionStatusChange(_handle_server_reboot));
_connection.register_data_callback(_on_data);
}
// gets as many data items that it can get in
// timeout milliseconds
public IEnumerable<bts.PubSubServerMessage> get_updates(TimeSpan timeout) {
_connection.doWork();
//List<bts.PubSubServerMessage> rv = new List<bts.PubSubServerMessage>();
List<byte[]> conn_data = _in_data_queue.dequeueMultipleElements(TimeSpan.Zero, 1024); // TODO, max_elements
if (conn_data.Count() > 0) {
bts.Log.Gen.info($"SingleServerSubscriberCore.get_updates n_updates: {conn_data.Count}");
}
List<bts.PubSubServerMessage> rv = new List<bts.PubSubServerMessage>();
foreach (var m in conn_data) {
var msg = new PubSubServerMessage();
msg.consruct_deserialize(m);
if (_tags.Contains(msg.tag))
rv.Add(msg);
else {
Log.Gen.warn("SingleSeverSubsciberCore.get_updates msg: {msg} does not have a subscription");
}
}
return rv;
}
private void _on_data(string sender, byte[] data) {
var data_txt = StreamUtilityMethods.first_n_bytes_to_string(data, 4);
bts.Log.Gen.info($"SingleServerSubscriberCore._on_data sender: {sender} data len: {data.Length} data: {data_txt}");
_in_data_queue.enqueue(data);
// TODO: enqueue, and dequeue in get_updates
}
public void subscribe(params string[] tags) {
HashSet<string> this_call_tags = new HashSet<string>();
foreach (string tag in tags) {
if (_tags.Contains(tag)) {
bts.Log.Gen.warn($"SingleServerSubscriberCore.subscribe tag: {tag} has already " +
$"been subscribed to server: {_connection.server_url}");
} else {
_tags.Add(tag);
this_call_tags.Add(tag);
}
}
_subscribe(this_call_tags.ToArray());
}
public void unsubscribe(params string[] tags) {
List<string> unsub_tags = new List<string>();
foreach (string tag in tags) {
if (_tags.Contains(tag)) {
_tags.Remove(tag);
unsub_tags.Add(tag);
} else {
bts.Log.Gen.warn($"tag {tag} is being unsubscribed from server {_connection.server_url}, eventhough " +
"it was never subscribed");
}
}
bts.PubSubClientMessage msg = new bts.PubSubClientMessage() {
msg_type = bts.PubSubMessageType.UNSUBSCRIIBE,
unsub_msg = new bts.UnsubscribeMsg() {
tags = unsub_tags.ToArray(),
connection = _connection.client_url,
subscribing_app = ClientInfo.thisClient.processString
}
};
_connection.send(msg);
}
#region IDisposable Members
public void Dispose() {
///remove the subscriber
//myConnection.send(new PubSubMessage(new MetaData(new RemoveSubscriberMetaData(myConnection.clientURL))).toStream());
// unsub all ?
_connection.Dispose();
//clear the list of tags you've subscribed to. This way, if you're ever used again,
//you have to send all the subscription metadata out again.
_tags.Clear();
}
#endregion
// The only place where a tag is subsribed from the Pubsub server. the subscriptions are wrapped into SubMetaData,
// which has a to_stream method
private void _subscribe(params string[] tag_args) {
// coonnection and app
bts.PubSubClientMessage msg = new bts.PubSubClientMessage() {
msg_type = bts.PubSubMessageType.SUBSCRIBE,
sub_msg = new bts.SubscribeMsg() {
connection = _connection.client_url,
subscribing_app = ClientInfo.thisClient.processString,
tags = tag_args
}
};
_connection.send(msg);
}
private void _handle_server_reboot(string server_url, bool connection) {
bts.Log.Gen.info($"SingleServerSubscriberCore._handle_server_reboot connection: {connection} server_url: {server_url}");
if (connection) {
_subscribe(_tags.ToArray());
} else {
bts.Log.Gen.warn($"SingleServerSubscriberCore._handle_server_reboot connection to {server_url} broke....attempting to reconnect...");
}
//let anyone watching you know that your connection has changed.
if (onPubSubConnectionChange != null)
onPubSubConnectionChange(connection, server_url);
}
// processes one message
// internal static void process_message(byte[] data, ref List<bts.PubSubServerMessage> updates) {
// bts.Log.Gen.info($"SingleServerSubscriberCore.process_message data_len: {data.Length}");
// if (data != null && data.Length > 0) {
// MemoryStream str = new MemoryStream(data);
// bts.PubSubServerMessage serv_msg = new bts.PubSubServerMessage();
// serv_msg.consruct_deserialize(str);
// updates.Add(serv_msg);
// }
// }
}
}