/// <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); }