public StatusMonitor() { _timer = new Timer(UpdateState, null, Timeout.Infinite, Timeout.Infinite); _connection = new Connection(Config.SignalRServer); _connection.Error += ConnectionOnError; _connection.Received += ConnectionOnReceived; }
static void Main(string[] args) { Task.Run(async () => { var conHub = new HubConnection("http://localhost:8080/"); conHub.CreateHubProxy("Shell").On<ShellCommandParams>("cmd", (data) => { }); using (var con = new Connection("http://localhost:8080/api/cmd")) { con.Received += (data) => { Console.WriteLine($"ola, recebi! {data}"); }; con.StateChanged += (state) => { if (state.NewState != state.OldState) { Console.WriteLine($"De {state.OldState} para {state.NewState}"); } }; await con.Start(); await con.Send("Hello Mello"); } }).Wait(); }
public ActivityClient( string ip, int port, IDevice device, bool useCache = true ) { LocalCaching = useCache; InitializeEvents(); Ip = ip; Port = port; Address = Net.GetUrl( ip, port, "" ).ToString(); Device = device; try { _eventHandler = new Connection(Address); _eventHandler.JsonSerializer.TypeNameHandling = TypeNameHandling.Objects; _eventHandler.Received += eventHandler_Received; _eventHandler.Start().Wait(); } catch(HttpClientException ex) { Console.WriteLine(ex.ToString()); } }
public RootControl() { InitializeComponent(); XmlConfigurator.Configure(); NetworkChange.NetworkAvailabilityChanged += (s, e) => { Console.WriteLine(e.IsAvailable); }; this.Loaded += (s, e) => { connection = new Connection(AppConfig.Host + "/Connections/PadControl"); connection.Received += Connection_Received; connection.StateChanged += Connection_StateChanged; connection.Closed += Connection_Closed; connection.ConnectionSlow += Connection_ConnectionSlow; connection.Start(); if (!AppConfig.AutoScale) { Window window = Window.GetWindow(this); window.WindowState = WindowState.Normal; Int32Rect displayBounds = AppConfig.DisplayBound; window.Left = displayBounds.X; window.Top = displayBounds.Y; window.Width = displayBounds.Width; window.Height = displayBounds.Height; } }; }
public void AppendCustomQueryStringAppendsConnectionQueryString(string connectionQs, string expected) { var connection = new Connection("http://foo.com", connectionQs); var urlQs = TransportHelper.AppendCustomQueryString(connection, "http://foo.com"); Assert.Equal(urlQs, expected); }
public void Dispose() { if (_conn != null) { _conn.Stop(); _conn = null; } }
public void GetReceiveQueryStringAppendsConnectionQueryString(string connectionQs, string expected) { var connection = new Connection("http://foo.com", connectionQs); connection.ConnectionToken = ""; var urlQs = TransportHelper.GetReceiveQueryString(connection, null, ""); Assert.True(urlQs.EndsWith(expected)); }
protected Connection CreateConnection(string url) { string testName = GetTestName() + "." + Interlocked.Increment(ref _id); var query = new Dictionary<string, string>(); query["test"] = testName; var connection = new Connection(url, query); connection.TraceWriter = HostedTestFactory.CreateClientTraceWriter(testName); return connection; }
public ConnectionService (string connectionUri) { connection = new Connection (connectionUri); connection.TraceLevel = Microsoft.AspNet.SignalR.Client.TraceLevels.All; connection.Closed += Connection_Closed; connection.Error += Connection_Error; connection.Received += Connection_Received; connection.Reconnecting += Connection_Reconnecting; connection.Reconnected += Connection_Reconnected; }
public Cache(string server) { if (!server.EndsWith("/")) { server += "/"; } _connection = new Connection(server + "cache"); _connection.Received += OnCacheEntryReceived; }
public void NoReconnectsAfterFallback() { // There was a regression where the SSE transport would try to reconnect after it times out. // This test ensures that no longer happens. // #2180 using (var host = new MemoryHost()) { var myReconnect = new MyReconnect(); host.Configure(app => { Func<AppFunc, AppFunc> middleware = (next) => { return env => { var request = new OwinRequest(env); var response = new OwinResponse(env); if (!request.Path.Value.Contains("negotiate") && !request.QueryString.Value.Contains("longPolling")) { response.Body = new MemoryStream(); } return next(env); }; }; app.Use(middleware); var config = new ConnectionConfiguration { Resolver = new DefaultDependencyResolver() }; config.Resolver.Register(typeof(MyReconnect), () => myReconnect); app.MapSignalR<MyReconnect>("/echo", config); }); var connection = new Connection("http://foo/echo"); using (connection) { connection.Start(host).Wait(); // Give SSE an opportunity to reconnect Thread.Sleep(TimeSpan.FromSeconds(5)); Assert.Equal(connection.State, ConnectionState.Connected); Assert.Equal(connection.Transport.Name, "longPolling"); Assert.Equal(0, myReconnect.Reconnects); } } }
public async Task RunAsync(string url) { _connection = new Connection(url); _connection.TraceWriter = _traceWriter; _connection.Received += (data) => { _traceWriter.WriteLine("received: " + data); }; await _connection.Start(); await _connection.Send(new { Type = "sendToMe", Content = "Hello World!" }); }
public void OnInitializedFiresFromInitializeMessage() { bool timedOut, disconnected, triggered = false; var connection = new Connection("http://foo.com"); TransportHelper.ProcessResponse(connection, "{\"S\":1, \"M\":[]}", out timedOut, out disconnected, () => { triggered = true; }); Assert.True(triggered); }
public MainWindow() { InitializeComponent(); this.Loaded += (s, e) => { connection = new Connection(AppConfig.Host + "/Connections/PadControl"); connection.Received += Connection_Received; connection.StateChanged += Connection_StateChanged; connection.Closed += Connection_Closed; connection.ConnectionSlow += Connection_ConnectionSlow; connection.Start(); }; }
public void Setup() { _signalRReceived = new List<object>(); _connection = new Connection("http://localhost:8989/signalr/rootfolder"); _connection.Start(new LongPollingTransport()).ContinueWith(task => { if (task.IsFaulted) { Assert.Fail("SignalrConnection failed. {0}", task.Exception.GetBaseException()); } }); _connection.Received += _connection_Received; }
static void Connect(Microsoft.AspNet.SignalR.Client.Connection connection) { Logger.Info("SignalR: Starting connection"); try { connection.Start(new LongPollingTransport()).Wait(); } catch (Exception exception) { Logger.Error(MaybeAggregateException(exception), "SignalR: Could not start connection"); throw; } }
public SignalRMessageBus(SignalRScaleoutConfiguration scaleoutConfiguration, IDependencyResolver dependencyResolver) : base(dependencyResolver, scaleoutConfiguration) { _connection = new Connection(scaleoutConfiguration.ServerUri.ToString()); _connection.Closed += connectionOnClosed; _connection.Received += notificationRecieved; _connection.Error += onConnectionOnError; var startTask = _connection.Start(); startTask.ContinueWith(t => { if (t.IsFaulted && t.Exception != null) throw t.Exception.GetBaseException(); }, TaskContinuationOptions.OnlyOnFaulted); startTask.ContinueWith(_ => Open(streamIndex), TaskContinuationOptions.OnlyOnRanToCompletion); }
public ActionResult Test(string input) { // Connect to the service var connection = new Connection("http://squarepegio.apphb.com/echo"); // Print the message when it comes in connection.Received += data => Console.WriteLine(data); // Start the connection connection.Start().Wait(); connection.Send(input).Wait(); return null; }
//leaving this as a compleately seperate system to event sending for now public static void Increment(string key) { // locking this operation so that it's thread safe if (incrementPersistantConnection == null) { lock (connectionLock) { //Console.WriteLine("Creating new persistant connection"); incrementPersistantConnection = new Connection(connectionUrl + "events/increment"); incrementPersistantConnection.Start().Wait(); //Console.WriteLine("Connection created"); } } incrementPersistantConnection.Send(key); }
static void Main(string[] args) { var connection = new Connection("http://localhost:3669/sensor/events"); connection.Start().Wait(); connection.AsObservable<SensorEvent>() .GroupBy(e => e.SensorId) .CombineLatest() .Select(latest => latest.Where(e => e.Reading > 0.75).ToList()) .Where(latest => latest.Count() >= 2) .Subscribe(latest => Console.WriteLine("Sensors {0} show readings greater than 0.75", string.Join(",", latest.Select(e => e.SensorId)))); Console.Read(); connection.Stop(); }
public async Task Start() { if (_conn != null) { return; } _conn = new Connection2(Urls.RealTimeMessaging); _conn.Headers["ak"] = App.Apikey; _conn.Headers["e"] = App.Environment.ToString(); _conn.Received += OnReceived; _conn.Closed += OnClosed; _conn.ConnectionSlow += OnConnectionSlow; _conn.Error += OnError; _conn.Reconnected += OnReconnected; _conn.Reconnecting += OnReconnecting; _conn.StateChanged += OnStatechange; await _conn.Start(); }
static void Main(string[] args) { // Connect to the service var connection = new Connection("http://localhost:6820/echo"); // Print the message when it comes in connection.Received += data => Console.WriteLine(data); // Start the connection connection.Start().Wait(); string line = null; while ((line = Console.ReadLine()) != null) { // Send a message to the server connection.Send(line).Wait(); } }
public static void Start() { const string url = "http://*****:*****@ {1}",connection.Url,DateTime.Now)); //Just a sample to test the concept Thread.Sleep(2000); } } catch (Exception exception) { Console.WriteLine(exception); } } })); Console.ReadLine(); //server.Dispose(); }
public SignalRMessageBus(SignalRScaleoutConfiguration scaleoutConfiguration, IDependencyResolver dependencyResolver) : base(dependencyResolver, scaleoutConfiguration) { _connection = new Connection(scaleoutConfiguration.ServerUri.ToString()); _connection.Received += notificationRecieved; _connection.Error += e => { Debug.WriteLine(e.ToString()); OnError(0, e); }; startTask = _connection.Start(); startTask.ContinueWith(t => { throw t.Exception.GetBaseException(); }, TaskContinuationOptions.OnlyOnFaulted); startTask.ContinueWith(_ => { Open(StreamIndex); }, TaskContinuationOptions.OnlyOnRanToCompletion); }
static void Main(string[] args) { try { var connection = new Connection("http://slabsignalrdemo.azurewebsites.net/semanticLogging"); connection.Received += data => { Console.WriteLine(data); }; connection.Start().ContinueWith(task => { if (task.IsFaulted) { Console.WriteLine("There was an error opening the connection:{0}", task.Exception.GetBaseException()); } else { Console.WriteLine("Connected"); } }).Wait(); connection.Error += Console.WriteLine; } catch (Exception ex) { Console.WriteLine(ex); } Console.WriteLine("Press enter to close"); Console.ReadLine(); }
public ActivityClient( string ip, int port, IDevice device ) { Ip = ip; Port = port; Address = Net.GetUrl( ip, port, "" ).ToString(); Device = device; Initialize(); try { _eventHandler = new Connection(Address); _eventHandler.Received += eventHandler_Received; _eventHandler.Start().Wait(); } catch(HttpClientException ex) { Console.WriteLine(ex.ToString()); } }
public MainWindow() { InitializeComponent(); var connection = new Connection("http://localhost:52029/echo"); connection.Received += data => { Console.WriteLine(data); }; connection.Start().ContinueWith(task => { if (task.IsFaulted) { Console.WriteLine("Failed to start: {0}", task.Exception.GetBaseException()); } else { Console.WriteLine("Success! Connected with client connection id {0}", connection.ConnectionId); // Do more stuff here } }); }
public ConnectionDown(Microsoft.AspNet.SignalR.Client.Connection connection) { Connection = connection; }
public async Task Start() { if (_conn != null) return; _conn = new Connection2(Urls.RealTimeMessaging); _conn.Headers["ak"] = App.Apikey; _conn.Headers["e"] = App.Environment.ToString(); _conn.Received += OnReceived; _conn.Closed += OnClosed; _conn.ConnectionSlow += OnConnectionSlow; _conn.Error += OnError; _conn.Reconnected += OnReconnected; _conn.Reconnecting += OnReconnecting; _conn.StateChanged += OnStatechange; await _conn.Start(); }
public void Stop() { if (_conn != null) { _conn.Stop(); _conn = null; } }
protected void ConnectSignalR() { _signalRReceived = new List<SignalRMessage>(); _signalrConnection = new Connection("http://localhost:8989/signalr"); _signalrConnection.Start(new LongPollingTransport()).ContinueWith(task => { if (task.IsFaulted) { Assert.Fail("SignalrConnection failed. {0}", task.Exception.GetBaseException()); } }); var retryCount = 0; while (_signalrConnection.State != ConnectionState.Connected) { if (retryCount > 25) { Assert.Fail("Couldn't establish signalr connection. State: {0}", _signalrConnection.State); } retryCount++; Console.WriteLine("Connecting to signalR" + _signalrConnection.State); Thread.Sleep(200); } _signalrConnection.Received += json => _signalRReceived.Add(Json.Deserialize<SignalRMessage>(json)); ; }
public void IntegrationTearDown() { if (_signalrConnection != null) { switch (_signalrConnection.State) { case ConnectionState.Connected: case ConnectionState.Connecting: { _signalrConnection.Stop(); break; } } _signalrConnection = null; _signalRReceived = new List<SignalRMessage>(); } }
public ClientServerMemoryRun(RunData runData) : base(runData) { _connections = new Connection[runData.Connections]; for (int i = 0; i < runData.Connections; i++) { _connections[i] = new Connection("http://memoryhost/echo"); } }