Files
spark/src/DataStreamSuite/PubSub/SingleServerSubscriberCore.cs
T
John Colvin 60a52b3922 cleanup: Fix numerous build warnings in DataStreamSuite
Nearly all warnings were due to nullability issues, since the concept of
nullable reference types did not exist when the DataStream code was
originally written.

* PubSubClientMessage
  - Normalize indentation/whitespace
  - Fix some typos
  - Address nullability issues to fix build warnings
  - Modernize code

* Compression related files
  - ZipEntry
  - ZipFile
  - ZipInputStream
  - TarHeader

* RemoteMessage
  - make 'message' nullable to resolve warnings elsewhere (in calling code)

* PubSubSingleTagStateEvent.cs
* PubSubMessageReactor
* PubSubState
* SystemHeartbeatPublisher
* SystemStatsPublisher
* SingleTagData
* ManagedTCPMessageHub
* PubsubDeserializationController
* PublisherCore
* InflaterHuffmanTree
* AsyncTCPConnection_APM
* ThreadSafeQueue
* ManagedSubscriber
* SubscriberCore
* PubSubServerManagedTCPConnection
* AsyncTCPConnection_APM
* SuperMapStream
* MapStream
* TradeBarsStream
2024-10-30 19:30:29 +00:00

158 lines
6.7 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.construct_deserialize(m);
if (_tags.Contains(msg.tag)) {
rv.Add(msg);
} else {
Log.Gen.warn($"SingleServerSubscriberCore.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
}
};
Log.Gen.info($"SingleServerSubscriberCore._subscribe sending msg: {msg}");
_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);
// }
// }
}
}