public RpcStreamingRequestResponseHandler(IStreamingClient client, string methodName) { MethodName = methodName; Client = client; Client.StreamingMessageReceived += RpcStreamingMessageResponseHandler; }
protected override void Cleanup() { if (_listener != null && _streamingClient != null) { _streamingClient.TearDownListener(_listener); } if (_listener != null) { _listener.Stop(); _listener.Dispose(); _listener = null; } if (_streamingClient != null) { _streamingClient.Dispose(); _streamingClient = null; } if (_client != null) { if (!string.IsNullOrEmpty(_client.Session)) _client.LogOut(); _client.Dispose(); _client = null; } }
public async Task HandleSubscription <T>( IStreamingClient client, RpcStreamingSubscriptionObservableHandler <T> subscription, Func <Task> subscribeFunc, Action <T> onNext, Func <Task> subscribeResponseFunc, CancellationToken cancellationToken) { subscription.GetSubscriptionDataResponsesAsObservable().Subscribe(onNext); var subscribed = false; subscription.GetSubscribeResponseAsObservable().Subscribe(async id => { subscribed = true; subscribeResponseFunc?.Invoke(); await _messagingService.SendLogMessage($"Subscribed ID: {id}"); }); subscription.GetUnsubscribeResponseAsObservable().Subscribe(async r => { subscribed = false; await _messagingService.SendLogMessage($"Unsubscribed result: {r}"); }); await client.StartAsync(); await subscribeFunc(); SpinWait.SpinUntil(() => subscribed && cancellationToken.IsCancellationRequested); await subscription.UnsubscribeAsync(); SpinWait.SpinUntil(() => !subscribed); }
public StreamingProtocolHandler(ILogger logger, IStreamingClient streamingClient) { _logger = logger; _streamingClient = streamingClient; _subscriptions = new ConcurrentDictionary <Request, IStreamingEventHandler>(); }
public static void Connect() { Console.WriteLine ("Connecting to CIAPI"); _rpcClient = new Client( new Uri(ConfigurationManager.AppSettings["Server"]), new Uri(ConfigurationManager.AppSettings["StreamingServer"]), ConfigurationManager.AppSettings["ApiKey"] ); _rpcClient.LogIn(ConfigurationManager.AppSettings["UserName"], ConfigurationManager.AppSettings["Password"]); _streamingClient = _rpcClient.CreateStreamingClient(); }
public static void Connect() { Console.WriteLine("Connecting to CIAPI"); _rpcClient = new Client( new Uri(ConfigurationManager.AppSettings["Server"]), new Uri(ConfigurationManager.AppSettings["StreamingServer"]), ConfigurationManager.AppSettings["ApiKey"]); _rpcClient.LogIn(ConfigurationManager.AppSettings["UserName"], ConfigurationManager.AppSettings["Password"]); _streamingClient = _rpcClient.CreateStreamingClient(); }
private void button2_Click(object sender, EventArgs e) { _rpcClient = new Client(new Uri(RpcUriTextBox.Text)); RpcClient.LogIn(UserNameTextBox.Text, PasswordTextBox.Text); _streamingClient = StreamingClientFactory.CreateStreamingClient(new Uri(StreamingUriTextBox.Text), UserNameTextBox.Text, RpcClient.Session); _streamingClient.Connect(); DialogResult = DialogResult.OK; }
public void ShouldThrowObjectDisposedException() { var client = this.BuildRpcClient(); client.LogIn(Settings.RpcUserName, Settings.RpcPassword); IStreamingClient streamingClient = client.CreateStreamingClient(); client.Dispose(); streamingClient.Dispose(); Assert.Throws(typeof(ObjectDisposedException), () => client.BeginLogIn("", "", a => { }, null), "async calls not guarded"); Assert.Throws(typeof(ObjectDisposedException), () => client.AccountInformation.GetClientAndTradingAccount(), "sync calls not guarded"); Assert.Throws(typeof(ObjectDisposedException), () => client.CreateStreamingClient(), "streaming client factory method not guarded"); Assert.Throws(typeof(ObjectDisposedException), () => streamingClient.BuildDefaultPricesListener(9), "streaming client listener factory method not guarded"); }
public void Dispose() { if (_newsListener != null) { _newsListener.Stop(); _newsListener = null; } if (_streamingClient != null) { _streamingClient.Disconnect(); _streamingClient = null; } if (_client != null) { _client.BeginLogOut(ar => _client.EndLogOut(ar), null); _client = null; } }
public EthApiService(IClient client, IStreamingClient streamingClient) : this(client, new TransactionManager(client)) { if (streamingClient == null) { _subscriptionService = new Lazy <EthSubscriptionService>(() => { throw new InvalidOperationException("Subscriptions require a streaming capable client to be configured"); }); } else { _subscriptionService = new Lazy <EthSubscriptionService>(() => { return(new EthSubscriptionService(streamingClient)); }); } }
private void BuildClients() { //Hook up a logger for the CIAPI.CS libraries LogManager.CreateInnerLogger = (logName, logLevel, showLevel, showDateTime, showLogName, dateTimeFormat) => new SimpleDebugAppender(logName, logLevel, showLevel, showDateTime, showLogName, dateTimeFormat); Dispatcher.BeginInvoke(() => listBox1.Items.Add("creating rpc client")); RpcClient = new Client(RpcUri, StreamingUri, "CI-WP7"); RpcClient.BeginLogIn(UerName, Password, ar => { try { RpcClient.EndLogIn(ar); //RpcClient.MagicNumberResolver.PreloadMagicNumbersAsync(); RpcClient.MagicNumberResolver.PreloadMagicNumbers(); ThreadPool.QueueUserWorkItem(_ => { Dispatcher.BeginInvoke(() => listBox1.Items.Add("creating listeners")); StreamingClient = RpcClient.CreateStreamingClient(); PriceListener = StreamingClient.BuildPricesListener(MarketId); PriceListener.MessageReceived += OnMessageReceived; Dispatcher.BeginInvoke(() => listBox1.Items.Add("getting account info")); RpcClient.AccountInformation.BeginGetClientAndTradingAccount(ar2 => { Account = RpcClient.AccountInformation.EndGetClientAndTradingAccount(ar2); Dispatcher.BeginInvoke(() => listBox1.Items.Add("getting market info")); RpcClient.Market.BeginGetMarketInformation(MarketId.ToString(), ar3 => { Market = RpcClient.Market.EndGetMarketInformation(ar3).MarketInformation; Dispatcher.BeginInvoke(() => Button1.IsEnabled = true); }, null); }, null); }); } catch (Exception ex) { Dispatcher.BeginInvoke(() => listBox1.Items.Add("exception caught: " + ex)); } }, null); }
/// <summary> /// Initializes a new instance of the <see cref="EventBus"/> class. /// </summary> /// <param name="streamingClient">The instance of <see cref="IStreamingClient"/> with connection to salesforce.</param> /// <param name="logger">The instance of <see cref="ILogger{SalesforceEventBus}"/>.</param> /// <param name="forceClient">The instance of <see cref="ForceClientProxy"/> to provide a publish functionality to the bus.</param> /// <param name="messageListeners"></param> /// <param name="options"></param> public EventBus( IStreamingClient streamingClient, ILogger <EventBus> logger, IResilientForceClient forceClient, IEnumerable <IMessageListener> messageListeners, IOptions <SalesforceConfiguration> options) { _streamingClient = streamingClient ?? throw new ArgumentNullException(nameof(streamingClient)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _forceClient = forceClient ?? throw new ArgumentNullException(nameof(forceClient)); _options = options.Value ?? throw new ArgumentNullException(nameof(options)); _messageListerners = messageListeners; _streamingClient.Reconnect += StreamingClient_Reconnect; _streamingClient.Handshake(); }
public override void Execute() { if (string.IsNullOrEmpty(ServerUrl)) throw new ApplicationException("StreamingLatencyMonitor: ServerUrl is not set"); lock (_sync) { if (_client == null) { _client = new Client(new Uri(ServerUrl), new Uri(StreamingServerUrl), "{API_KEY}", 1); _client.LogIn(UserName, Password); _streamingClient = _client.CreateStreamingClient(); _streamingStartTime = DateTime.UtcNow; _listener = _streamingClient.BuildPricesListener(MarketId); _listener.MessageReceived += OnPriceUpdate; } } }
private void BuildClients() { Dispatcher.BeginInvoke(() => listBox1.Items.Add("creating rpc client")); RpcClient = new Client(RpcUri, StreamingUri, "CI-WP7"); RpcClient.BeginLogIn(UerName, Password, ar => { try { RpcClient.EndLogIn(ar); ThreadPool.QueueUserWorkItem(_ => { Dispatcher.BeginInvoke(() => listBox1.Items.Add("creating listeners")); StreamingClient = RpcClient.CreateStreamingClient(); PriceListener = StreamingClient.BuildPricesListener(MarketId); PriceListener.MessageReceived += OnMessageReceived; Dispatcher.BeginInvoke(() => listBox1.Items.Add("getting account info")); RpcClient.AccountInformation.BeginGetClientAndTradingAccount(ar2 => { Account = RpcClient.AccountInformation.EndGetClientAndTradingAccount(ar2); Dispatcher.BeginInvoke(() => listBox1.Items.Add("getting market info")); RpcClient.Market.BeginGetMarketInformation(MarketId.ToString(), ar3 => { Market = RpcClient.Market.EndGetMarketInformation(ar3).MarketInformation; Dispatcher.BeginInvoke(() => Button1.IsEnabled = true); }, null); }, null); }); } catch (Exception ex) { Dispatcher.BeginInvoke(() => listBox1.Items.Add("exception caught: " + ex)); } }, null); }
public override async Task ExecuteAsync(IStreamingClient client) { var subscription = new EthNewBlockHeadersSubscription(client); await subscription.SendRequestAsync(Guid.NewGuid()); }
public abstract Task ExecuteAsync(IStreamingClient client);
public DemoCompressingController(IStreamingClient streamingClient) { _streamingClient = streamingClient; }
private void ToggleSubscribeButton_Click(object sender, RoutedEventArgs e) { if (ToggleSubscribeButtonlabel.Text == "Subscribe") { _rcpClient = new Rpc.Client(new Uri(RpcUriTextbox.Text)); var userName = UserNameTextbox.Text; var streamingUri = new Uri(StreamingUriTextbox.Text); var topic = TopicTextbox.Text; Log("Creating session..."); _rcpClient.BeginLogIn(userName, PasswordTextbox.Text, loginResult => { try { _rcpClient.EndLogIn(loginResult); _logger.DebugFormat("Session is: {0}", _rcpClient.SessionId); Log("Creating streaming client..."); _streamingClient = StreamingClientFactory.CreateStreamingClient(streamingUri, userName, _rcpClient.SessionId); _streamingClient.StatusChanged += (s, message) => Log(string.Format("Status update: {0}", message.Status)); _streamingClient.Connect(); Log("Listening to news stream..."); _newsListener = _streamingClient.BuildListener<NewsDTO>(topic); _newsListener.Start(); _newsListener.MessageRecieved += (s, message) => { try { NewsDTO recievedNewsHeadline = message.Data; Log( string.Format( "Recieved: NewsDTO: StoryId {0}, Headline {1}, PublishDate = {2}", recievedNewsHeadline.StoryId, recievedNewsHeadline.Headline, recievedNewsHeadline.PublishDate.ToString("u"))); } catch (Exception exception) { _logger.Error("Exception occured:", exception); } }; } catch (Exception exception) { _logger.Error("Exception occured:", exception); } }, null); ToggleSubscribeButtonlabel.Text = "Stop"; } else { try { Log("Stopping listening to news stream..."); // D: abbreviating conditionals makes it hard to step // and is also a good way to get bugs. you may notice that I always use // blocks. if (_newsListener != null) { _newsListener.Stop(); } Log("Disconnecting from streaming server..."); if (_streamingClient != null) { _streamingClient.Disconnect(); } Log("Deleting session..."); if (_rcpClient != null ) { // REMOVEME: i commented this out and still getting the ObjectDisposed exception // so it is not in the RpcClient _rcpClient.BeginLogOut(logoutResult => { // FIXME: id/session invalid - getting back LoggedOut: false /*do nothing*/ var breakTarget = 0; }, null); } } catch (Exception exception) { _logger.Error("Exception occured:", exception); } ToggleSubscribeButtonlabel.Text = "Subscribe"; } }
public EthApiContractService(IClient client, IStreamingClient streamingClient) : base(client, streamingClient) { }
protected RpcStreamingResponseParamsObservableHandler(IStreamingClient streamingClient, TRpcRequestResponseHandler rpcRequestResponseHandler) : base(streamingClient) { RpcRequestResponseHandler = rpcRequestResponseHandler; }
protected RpcStreamingSubscriptionHandler(IStreamingClient streamingClient, IUnsubscribeSubscriptionRpcRequestBuilder unsubscribeSubscriptionRpcRequestBuilder) { StreamingClient = streamingClient; UnsubscribeSubscriptionRpcRequestBuilder = unsubscribeSubscriptionRpcRequestBuilder; }
protected RpcStreamingSubscriptionEventResponseHandler(IStreamingClient streamingClient, IUnsubscribeSubscriptionRpcRequestBuilder unsubscribeSubscriptionRpcRequestBuilder) : base(streamingClient, unsubscribeSubscriptionRpcRequestBuilder) { }
public EthNewPendingTransactionSubscription(IStreamingClient client) : base(client, ApiMethods.eth_subscribe.ToString()) { }
public async Task ExecuteTestAsync(IStreamingClient client) { await ExecuteAsync(client); }
protected RpcStreamingRequestResponseHandler(IStreamingClient streamingClient) { StreamingClient = streamingClient; }
public Web3(IClient client, IStreamingClient streamingClient) : this(client) { StreamingClient = streamingClient; }
protected RpcStreamingResponseObservableHandler(IStreamingClient streamingClient) : base(streamingClient) { ResponseSubject = new Subject <TResponse>(); }
public EthNewSyncingSubscription(IStreamingClient client) : base(client, ApiMethods.eth_newFilter.ToString()) { }
public EthNewBlockHeadersSubscription(IStreamingClient client) : base(client, new EthUnsubscribeRequestBuilder()) { _ethNewBlockHeadersSubscriptionRequestBuilder = new EthNewBlockHeadersSubscriptionRequestBuilder(); }
public DemoStreamingController(IStreamingClient streamingClient) { _streamingClient = streamingClient; }
void SubscribeNewsUpdates(Action<NewsDTO> onUpdate, Action<Exception> onError) { _client = new Client(RPC_URI); _client.BeginLogIn(USERNAME, PASSWORD, ar => { try { _client.EndLogIn(ar); Debug.WriteLine("Login ok"); _streamingClient = StreamingClientFactory.CreateStreamingClient( STREAMING_URI, USERNAME, _client.SessionId); _streamingClient.Connect(); Debug.WriteLine("\r\n\r\n\r\n\r\n\r\nStreaming connected ok"); _newsListener = _streamingClient.BuildListener<NewsDTO>("NEWS.MOCKHEADLINES.UK"); _newsListener.MessageRecieved += (s, e) => { var msg = e.Data.Headline; Debug.WriteLine(msg); //onUpdate(e.Data); }; _newsListener.Start(); Debug.WriteLine("\r\n\r\n\r\n\r\n\r\nListener started ok"); } catch (Exception exc) { onError(exc); } }, null); }
public EthLogsObservableSubscription(IStreamingClient client) : base(client, new EthUnsubscribeRequestBuilder()) { _ethLogsSubscriptionRequestBuilder = new EthLogsSubscriptionRequestBuilder(); }
public EthNewBlockHeadersSubscription(IStreamingClient client) : base(client, ApiMethods.eth_subscribe.ToString()) { }
public EthGetBalanceObservableHandler(IStreamingClient streamingClient) : base(streamingClient, new EthGetBalance(null)) { }
public EthSyncingSubscription(IStreamingClient client) : base(client, new EthUnsubscribeRequestBuilder()) { _builder = new EthSyncingSubscriptionRequestBuilder(); }
public EthNewPendingTransactionObservableSubscription(IStreamingClient client) : base(client, new EthUnsubscribeRequestBuilder()) { _builder = new EthNewPendingTransactionSubscriptionRequestBuilder(); }
public EthBlockNumberObservableHandler(IStreamingClient streamingClient) : base(streamingClient, new EthBlockNumber(null)) { }
public EthSubscriptionService(IStreamingClient client) : base(client) { NewPendingTransactionSubscription = new EthNewPendingTransactionSubscription(client); NewBlockHeadersSubscription = new EthNewBlockHeadersSubscription(client); }