/// <summary>
/// Subscribe for notifications whenever the state of the DataSource changes.
///
/// <para />All changes will be observed on the provided executor.
/// <param name="dataSubscriber"></param>
/// <param name="executor"></param>
/// </summary>
public override void Subscribe(IDataSubscriber <T> dataSubscriber, IExecutorService executor)
{
AddMethodInvocation("Subscribe");
DataSubscriber = dataSubscriber;
if (_setState)
{
switch (_response)
{
case DataSourceTestUtils.NO_INTERACTIONS:
break;
case DataSourceTestUtils.ON_NEW_RESULT:
dataSubscriber.OnNewResult(this);
break;
case DataSourceTestUtils.ON_FAILURE:
dataSubscriber.OnFailure(this);
break;
case DataSourceTestUtils.ON_CANCELLATION:
dataSubscriber.OnCancellation(this);
break;
}
}
else
{
base.Subscribe(dataSubscriber, executor);
}
}
public void SubscribeDataTest()
{
CurvesData.LSTCurvesData.Clear();
APIHandlerTests api = new APIHandlerTests();
api.InvokeDataTransfferAsyncTest();
string p = string.Empty;
try
{
using (ShimsContext.Create())
{
ShimDataSubscriber.Constructor = (a) => { };
dataSubscriber = new DataSubscriber();
ShimConfigurationManager.AppSettingsGet = () => { return(config); };
ShimLogger.WrieExceptionString = (a) => { p = a; };
dataSubscriber.ConnectToRabbitMQ();
dataSubscriber.SubscribeData();
}
Thread.Sleep(10000);
var j = CurvesData.LSTCurvesData;
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
/// <summary>
/// Subscribe for notifications whenever the state of the IDataSource
/// changes.
///
/// <para />All changes will be observed on the provided executor.
/// </summary>
public virtual void Subscribe(
IDataSubscriber <T> dataSubscriber,
IExecutorService executor)
{
Preconditions.CheckNotNull(dataSubscriber);
Preconditions.CheckNotNull(executor);
bool shouldNotify;
lock (_gate)
{
if (_isClosed)
{
return;
}
if (_dataSourceStatus == DataSourceStatus.IN_PROGRESS)
{
_subscribers.Add(
new Tuple <IDataSubscriber <T>,
IExecutorService>(dataSubscriber, executor));
}
shouldNotify = HasResult() || IsFinished() || WasCancelled();
}
if (shouldNotify)
{
NotifyDataSubscriber(dataSubscriber, executor, HasFailed(), WasCancelled());
}
}
public DDPClient(IDataSubscriber subscriber)
{
this._connector = new DDPConnector(this);
this._connector.SocketError += new SocketErrorEventHandler(_connector_Error);
this._queueHandler = new ResultQueue(subscriber);
_uniqueId = 1;
}
public static void Connect(string url, IDataSubscriber dataSubscriber)
{
if (_client == null)
_client = new DDPClient(dataSubscriber);
_client.Connect(url);
}
//Removes a symbol from the watch list and returns true if no other subscribers are
//watching that symbol (allows the overriding class to remove the symbol from the API).
public bool RemoveWatch(string Symbol, IDataSubscriber Subscriber)
{
bool notInUse = false;
for (int n = 0; n < m_WatchList.Count; n++)
{
if (n >= m_WatchList.Count)
{
break;
}
if (m_WatchList[n].Symbol == Symbol && m_WatchList[n].Subscriber != null)
{
if (m_WatchList[n].Subscriber.GetHandle() == Subscriber.GetHandle())
{
m_WatchList.RemoveAt(n);
notInUse = true;
}
else
{
return(false);
}
}
}
return(notInUse);
}
public void TestLifecycle_I1_C_S1()
{
IDataSource <object> dataSource = GetAndSubscribe();
IDataSubscriber <object> subscriber1 = VerifyGetAndSubscribe(_dataSourceSupplier1, _src1);
object val1 = new object();
((MockAbstractDataSource <object>)_src1).SetState(
DataSourceTestUtils.NOT_CLOSED,
DataSourceTestUtils.NOT_FINISHED,
DataSourceTestUtils.WITH_RESULT,
val1,
DataSourceTestUtils.NOT_FAILED,
null);
subscriber1.OnNewResult(_src1);
VerifySubscriber(dataSource, _src1, DataSourceTestUtils.ON_NEW_RESULT);
VerifyState(
((AbstractDataSource <object>)dataSource),
_src1,
DataSourceTestUtils.NOT_CLOSED,
DataSourceTestUtils.NOT_FINISHED,
DataSourceTestUtils.WITH_RESULT,
val1,
DataSourceTestUtils.NOT_FAILED,
null);
TestClose(dataSource, _src1);
VerifySubscriber(dataSource, null, DataSourceTestUtils.ON_CANCELLATION);
VerifyState(
((AbstractDataSource <object>)dataSource),
null,
DataSourceTestUtils.CLOSED,
DataSourceTestUtils.NOT_FINISHED,
DataSourceTestUtils.WITHOUT_RESULT,
null,
DataSourceTestUtils.NOT_FAILED,
null);
object val = new object();
((MockAbstractDataSource <object>)_src1).SetState(
DataSourceTestUtils.NOT_CLOSED,
DataSourceTestUtils.FINISHED,
DataSourceTestUtils.WITH_RESULT,
val,
DataSourceTestUtils.NOT_FAILED,
null);
subscriber1.OnNewResult(_src1);
VerifySubscriber(dataSource, _src1, DataSourceTestUtils.NO_INTERACTIONS);
VerifyState(
((AbstractDataSource <object>)dataSource),
null,
DataSourceTestUtils.CLOSED,
DataSourceTestUtils.NOT_FINISHED,
DataSourceTestUtils.WITHOUT_RESULT,
null,
DataSourceTestUtils.NOT_FAILED,
null);
}
public void Initialize()
{
_executor1 = CallerThreadExecutor.Instance;
_executor2 = CallerThreadExecutor.Instance;
_dataSubscriber1 = new MockDataSubscriber <IValue>();
_dataSubscriber2 = new MockDataSubscriber <IValue>();
_dataSource = new FakeAbstractDataSource();
}
public void AddSubscriber(IDataSubscriber <TWorkProduct> subscriber)
{
if (TrySubscribeToWorker(subscriber))
{
return;
}
_productSubscribers.Enqueue(subscriber);
}
public void TestLifecycle_F1_S2_C()
{
IDataSource <object> dataSource = GetAndSubscribe();
IDataSubscriber <object> subscriber1 = VerifyGetAndSubscribe(_dataSourceSupplier1, _src1);
((MockAbstractDataSource <object>)_src1).SetState(
DataSourceTestUtils.NOT_CLOSED,
DataSourceTestUtils.FINISHED,
DataSourceTestUtils.WITHOUT_RESULT,
null,
DataSourceTestUtils.FAILED,
new Exception());
subscriber1.OnFailure(_src1);
Assert.IsTrue(((MockAbstractDataSource <object>)_src1).VerifyMethodInvocation("Close", 1));
IDataSubscriber <object> subscriber2 = VerifyGetAndSubscribe(_dataSourceSupplier2, _src2);
VerifyState(
((AbstractDataSource <object>)dataSource),
null,
DataSourceTestUtils.NOT_CLOSED,
DataSourceTestUtils.NOT_FINISHED,
DataSourceTestUtils.WITHOUT_RESULT,
null,
DataSourceTestUtils.NOT_FAILED,
null);
object val = new object();
((MockAbstractDataSource <object>)_src2).SetState(
DataSourceTestUtils.NOT_CLOSED,
DataSourceTestUtils.FINISHED,
DataSourceTestUtils.WITH_RESULT,
val,
DataSourceTestUtils.NOT_FAILED,
null);
subscriber2.OnNewResult(_src2);
VerifySubscriber(dataSource, _src2, DataSourceTestUtils.ON_NEW_RESULT);
VerifyState(
((AbstractDataSource <object>)dataSource),
_src2,
DataSourceTestUtils.NOT_CLOSED,
DataSourceTestUtils.FINISHED,
DataSourceTestUtils.WITH_RESULT,
val,
DataSourceTestUtils.NOT_FAILED,
null);
TestClose(dataSource, _src2);
VerifyState(
((AbstractDataSource <object>)dataSource),
null,
DataSourceTestUtils.CLOSED,
DataSourceTestUtils.FINISHED,
DataSourceTestUtils.WITHOUT_RESULT,
null,
DataSourceTestUtils.NOT_FAILED,
null);
}
public IDataSubscribable GetDataSource(IDataSubscriber forWorker)
{
var argType = forWorker.GetType().GenericTypeArguments.FirstOrDefault();
var imp = _typeFinder.GetImplementation <IDataSubscribable>(
argType, GetAllPublishers());
return(imp);
}
public static void Connect(string url, IDataSubscriber dataSubscriber)
{
if (_client == null)
{
_client = new DDPClient(dataSubscriber);
}
_client.Connect(url);
}
public ResultQueue(IDataSubscriber subscriber)
{
this._jsonItemsQueue = new Queue<string>();
this._serializeHelper = new JsonDeserializeHelper(subscriber);
_enqueuedEvent = new ManualResetEvent(false);
_workerThread = new Thread(new ThreadStart(PerformDeserilization));
_workerThread.Start();
}
/// <summary>
/// Subscribe to a specific data type
/// </summary>
/// <typeparam name="T">the data type for which to receive values</typeparam>
/// <param name="subscriber">the subscribing element</param>
public static void Subscribe <T>(IDataSubscriber subscriber)
{
//Debug.WriteLine(string.Format("DataKiosk subscriber: {0}, type {1}", subscriber.GetType().Name, typeof(T)));
var subscriberEventHandler = GetSubscriptions(typeof(T));
Subscribers[typeof(T)] =
(DataPublishedEventHandler)Delegate.Combine(subscriberEventHandler, (DataPublishedEventHandler)subscriber.OnDataPublished);
}
public ResultQueue(IDataSubscriber subscriber)
{
this._jsonItemsQueue = new Queue <string>();
_enqueuedEvent = new ManualResetEvent(false);
_serializeHelper = new JsonDeserializeHelper(subscriber);
_workerThread = new Thread(new ThreadStart(PerformDeserilization));
_workerThread.Start();
}
public void InitDataSubscriber(IDataSubscriber subscriber)
{
lock (_subscribers)
{
if (!_subscribers.Contains(subscriber))
{
_subscribers.Add(subscriber);
}
}
}
private Boolean TrySubscribeToWorker(IDataSubscriber subscriber)
{
var source = WorkerProvider.GetDataSource(subscriber);
if (source != null)
{
source.AddSubscriber(subscriber);
return(true);
}
return(false);
}
public void RemoveDataSubscriber(IDataSubscriber subscriber)
{
lock (_subscribers)
{
if (_subscribers.Contains(subscriber))
{
_subscribers.Remove(subscriber);
subscriber.UnSubscribeAll();
}
}
}
public void AddSubscriber(IDataSubscriber subscriber)
{
if (subscriber is IDataSubscriber <TOutput> tSub)
{
_agent.AddSubscriber(tSub);
}
else
{
throw new Exception(subscriber + " cannot subscribe to " + GetType().Name);
}
}
/// <summary>
/// Notifies progress update.
/// </summary>
protected void NotifyProgressUpdate()
{
foreach (var pair in _subscribers)
{
IDataSubscriber <T> subscriber = pair.Item1;
IExecutorService executor = pair.Item2;
executor.Execute(() =>
{
subscriber.OnProgressUpdate(this);
});
}
}
public Boolean TryAddSubscriber <TInput>(IDataSubscriber <TInput> subscriber)
{
var source = _publisherContainer.GetDataSource <TInput>();
if (source == null)
{
return(false);
}
source.AddSubscriber(subscriber);
return(true);
}
public override Boolean TryAddSubscriber <TWorkItem>(
IDataSubscriber <TWorkItem> subscriber)
{
var src = _processor.GetDataSource <TWorkItem>() ??
_workers.GetDataSource <TWorkItem>();
if (src == null)
{
return(_publishers.TryAddSubscriber(subscriber));
}
src.AddSubscriber(subscriber);
return(true);
}
/// <summary>
/// Initialize the client with a DDPConnector, subscriber and ResultQueue.
/// This shouldnt be user facing, but is necessary in the concrete classes.
/// </summary>
/// <returns>The init.</returns>
/// <param name="connector">Connector for sending DDP Messages</param>
/// <param name="subscriber">Subscriber for subscribing to DDP Messages</param>
/// <param name="queue">Message queue</param>
protected void Init(IDDPConnector connector, IDataSubscriber subscriber, IResultQueue queue)
{
this._connector = connector;
this._subscriber = subscriber;
this._queueHandler = queue;
_subscriber.MessageReceived += (msg) =>
{
if (MessageReceived != null)
{
MessageReceived(msg);
}
};
}
//Adds a selection to the watch list. It will automatically
//be removed from the watch list after the client is destroyed.
public void AddWatch(string Symbol, IDataSubscriber Subscriber, Periodicity BarType, int BarSize)
{
if (Subscriber == null)
{
return;
}
m_WatchList.Add(new WatchItem
{
Symbol = Symbol,
BarType = BarType,
BarSize = BarSize,
Subscriber = Subscriber,
Bars = new List <M4.DataServer.Interface.BarData>()
});
}
private Boolean TryContrivePublisher <TWorkItem>(
IDataSubscriber <TWorkItem> worker)
{
var emitters = _workers.GetAllWorkers().OfType <
IDataEmitter <TWorkItem> >().ToArray();
if (!emitters.Any())
{
return(false);
}
var emitter = emitters.Last();
ContriveEmitter <TInput, TWorkItem>(emitter, worker);
return(true);
}
public override void AddSubscriber(IDataSubscriber subscriber)
{
if (TrySubscribeToWorker(subscriber))
{
return;
}
if (subscriber is IDataSubscriber <TWorkProduct> twp)
{
_productSubscribers.Enqueue(twp);
}
else
{
throw new Exception("Unable to add " + subscriber + " as a subscriber");
}
}
/// <summary>
/// Unsubscribe from a specific data type
/// </summary>
/// <typeparam name="T">the data type for which to receive values</typeparam>
/// <param name="subscriber">the unsubscribing element</param>
public static void Unsubscribe <T>(IDataSubscriber subscriber)
{
var subscriberEventHandler = GetSubscriptions(typeof(T));
if (subscriberEventHandler == null)
{
return;
}
Subscribers[typeof(T)] = (DataPublishedEventHandler)Delegate.Remove(subscriberEventHandler, (DataPublishedEventHandler)subscriber.OnDataPublished);
// if the last subscriber has been removed, then we remove the last value as well
if (subscriberEventHandler.GetInvocationList().Count() == 0)
{
LastPublishedValues.Remove(typeof(T));
}
}
public void Initialize()
{
_resourceReleaser = new ResourceReleaserImpl <int>(_ => { });
_dataSubscriber = new MockDataSubscriber <IList <CloseableReference <int> > >();
_settableDataSource1 = SettableDataSource <int> .Create <int>();
_settableDataSource2 = SettableDataSource <int> .Create <int>();
_listDataSource = ListDataSource <int> .Create(_settableDataSource1, _settableDataSource2);
_ref1 = CloseableReference <int> .of(1, _resourceReleaser);
_ref2 = CloseableReference <int> .of(2, _resourceReleaser);
_runtimeException = new Exception();
_listDataSource.Subscribe(_dataSubscriber, CallerThreadExecutor.Instance);
}
public void TestLifecycle_C()
{
IDataSource <object> dataSource = GetAndSubscribe();
IDataSubscriber <object> subscriber1 = VerifyGetAndSubscribe(_dataSourceSupplier1, _src1);
TestClose(dataSource, _src1);
VerifySubscriber(dataSource, null, DataSourceTestUtils.ON_CANCELLATION);
VerifyState(
((AbstractDataSource <object>)dataSource),
null,
DataSourceTestUtils.CLOSED,
DataSourceTestUtils.NOT_FINISHED,
DataSourceTestUtils.WITHOUT_RESULT,
null,
DataSourceTestUtils.NOT_FAILED,
null);
}
private void ContriveEmitter <TWorkItem, TOutput>(
IDataEmitter <TOutput> emitter, IDataSubscriber <TOutput> subscriber)
{
switch (emitter)
{
case IOneToOneWorker <TWorkItem, TOutput> oneToOne:
var cnt = new ContrivedOneToOneSubscribable
<TWorkItem, TOutput>(oneToOne);
cnt.AddSubscriber(subscriber);
AddWorker(cnt);
break;
case IOneToManyWorker <TWorkItem, TOutput> oneToMany:
var cntx = new ContrivedOneToManySubscribable
<TWorkItem, TOutput>(oneToMany);
cntx.AddSubscriber(subscriber);
AddWorker(cntx);
break;
}
}
public void ConnectToRabbitMQTest()
{
string p = string.Empty;
try
{
using (ShimsContext.Create())
{
ShimDataSubscriber.Constructor = (a) => { };
dataSubscriber = new DataSubscriber();
ShimConfigurationManager.AppSettingsGet = () => { return(config); };
ShimLogger.WrieExceptionString = (a) => { p = a; };
dataSubscriber.ConnectToRabbitMQ();
}
}
catch (Exception ex)
{
Assert.Fail(ex.Message);
}
}
private void NotifyDataSubscriber(
IDataSubscriber <T> dataSubscriber,
IExecutorService executor,
bool isFailure,
bool isCancellation)
{
executor.Execute(() =>
{
if (isFailure)
{
dataSubscriber.OnFailure(this);
}
else if (isCancellation)
{
dataSubscriber.OnCancellation(this);
}
else
{
dataSubscriber.OnNewResult(this);
}
});
}
public DDPClient(IDataSubscriber subscriber)
{
_connector = new DDPConnector(this);
_queueHandler = new ResultQueue(subscriber);
_uniqueId = 1;
}
public DDPClient(IDataSubscriber subscriber) : this(new DdpConnector(), new DefaultQueueProcessor<string>(new JsonDeserializeHelper(subscriber).Deserialize))
{
}
public JsonDeserializeHelper(IDataSubscriber subscriber)
{
this._subscriber = subscriber;
}
/// <summary>
///
/// </summary>
/// <param name="listenToUrl">will be the url other .net clients will connect and get the notifications</param>
/// <param name="meteorServerUrl">url where meteor server application is running</param>
public DDPClientHost(string listenToUrl, string meteorServerUrl)
{
_listenToUrl = listenToUrl;
_meteorServerUrl = meteorServerUrl;
_dataSubscriber = new DataSubscriber();
}
public void CreateDDPClient(IDataSubscriber subscriber)
{
client = new DDPClient(subscriber);
}
