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 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;
}
};
}
private async Task RunPersistentConnection(string url, CookieContainer cookieContainer)
{
_traceWriter.WriteLine();
_traceWriter.WriteLine("*** Persistent Connection ***");
using (var connection = new Connection(url + "echo"))
{
connection.CookieContainer = cookieContainer;
connection.TraceWriter = _traceWriter;
connection.Received += data =>
{
connection.TraceWriter.WriteLine("Received: " + data);
};
connection.Error += exception =>
{
connection.TraceWriter.WriteLine("Error: {0}: {1}" + exception.GetType(), exception.Message);
};
await connection.Start();
await connection.Send("sending to AuthorizeEchoConnection");
await Task.Delay(TimeSpan.FromSeconds(2));
}
}
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 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!" });
}
private void RunRawConnection(string serverUrl)
{
string url = serverUrl + "raw-connection";
var connection = new Connection(url);
connection.TraceWriter = _traceWriter;
connection.Start().Wait();
connection.TraceWriter.WriteLine("transport.Name={0}", connection.Transport.Name);
connection.Send(new { type = 1, value = "first message" }).Wait();
connection.Send(new { type = 1, value = "second message" }).Wait();
}
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;
}
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();
};
}
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 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;
}
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);
}
private async Task RunPersistentConnection(string url, HttpClient httpClient, CookieContainer cookieContainer, string requestVerificationToken)
{
_traceWriter.WriteLine();
_traceWriter.WriteLine("*** Persistent Connection ***");
using (var connection = new Connection(url + "echo"))
{
connection.CookieContainer = cookieContainer;
connection.TraceWriter = _traceWriter;
connection.Received += (data) => connection.TraceWriter.WriteLine("Received: " + data);
connection.Error += (exception) => connection.TraceWriter.WriteLine(string.Format("Error: {0}: {1}" + exception.GetType(), exception.Message));
await connection.Start(GetClientTransport());
await connection.Send("sending to AuthorizeEchoConnection");
await Task.Delay(TimeSpan.FromSeconds(2));
}
}
//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();
}
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 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 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);
}
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());
}
}
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 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 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();
}
private static Task ConnectBatch(string url, string transport, int batchSize, ConcurrentBag<Connection> connections)
{
var options = new ParallelOptions
{
MaxDegreeOfParallelism = batchSize
};
var batchTcs = new TaskCompletionSource<object>();
long remaining = batchSize;
Parallel.For(0, batchSize, options, async i =>
{
var connection = new Connection(url);
if (!_running)
{
batchTcs.TrySetResult(null);
return;
}
try
{
var clientTransport = GetTransport(transport);
await (clientTransport == null ? connection.Start() : connection.Start(clientTransport));
if (_running)
{
connections.Add(connection);
var clientId = connection.ConnectionId;
connection.Error += e =>
{
Debug.WriteLine(String.Format("SIGNALR: Client {0} ERROR: {1}", clientId, e));
};
connection.Closed += () =>
{
Debug.WriteLine(String.Format("SIGNALR: Client {0} CLOSED", clientId));
// Remove it from the list on close
connections.TryTake(out connection);
};
}
}
catch (Exception ex)
{
Console.WriteLine("Failed to start client. {0}", ex.GetBaseException());
}
finally
{
if (Interlocked.Decrement(ref remaining) == 0)
{
// When all connections are connected, mark the task as complete
batchTcs.TrySetResult(null);
}
}
});
return batchTcs.Task;
}
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)); ;
}
private async Task RunAuth(string serverUrl)
{
string url = serverUrl + "cookieauth";
var handler = new HttpClientHandler();
handler.CookieContainer = new CookieContainer();
using (var httpClient = new HttpClient(handler))
{
var content = string.Format("UserName={0}&Password={1}", "user", "password");
var response = httpClient.PostAsync(url + "/Account/Login", new StringContent(content, Encoding.UTF8, "application/x-www-form-urlencoded")).Result;
}
var connection = new Connection(url + "/echo");
connection.TraceWriter = _traceWriter;
connection.Received += (data) => connection.TraceWriter.WriteLine(data);
#if !ANDROID && !iOS
connection.CookieContainer = handler.CookieContainer;
#endif
await connection.Start();
await connection.Send("sending to AuthenticatedEchoConnection");
var hubConnection = new HubConnection(url);
hubConnection.TraceWriter = _traceWriter;
#if !ANDROID && !iOS
hubConnection.CookieContainer = handler.CookieContainer;
#endif
var hubProxy = hubConnection.CreateHubProxy("AuthHub");
hubProxy.On<string, string>("invoked", (connectionId, date) => hubConnection.TraceWriter.WriteLine("connectionId={0}, date={1}", connectionId, date));
await hubConnection.Start();
hubConnection.TraceWriter.WriteLine("transport.Name={0}", hubConnection.Transport.Name);
await hubProxy.Invoke("InvokedFromClient");
}
private async Task RunStreaming(string serverUrl)
{
string url = serverUrl + "streaming-connection";
var connection = new Connection(url);
connection.TraceWriter = _traceWriter;
await connection.Start();
connection.TraceWriter.WriteLine("transport.Name={0}", connection.Transport.Name);
}
private void Action_Click(object sender, RoutedEventArgs e)
{
msgTxtBlock.Text = "";
if (Action.Content.ToString() == "Start")
{
// Read the signalrPortNumber
// The signalrClient will be listening at this port number
string signalrPortNumber = Utilities.GetAppsettingsValue("signalrPortNumber");
string signalrServer = "http://localhost:" + signalrPortNumber + "/listener";
if (tracingEnabled == true)
{
signalRConnectionProgressBar.Visibility = System.Windows.Visibility.Visible;
DisplayMessage("Connecting ...",false);
signalrConnectionTimer.Start();
connectionTimedOut = false;
if (connection == null)
{
connection = new Connection(signalrServer);
try
{
connection.Start();
}
catch(Exception ex)
{
if (Utilities.GetAppsettingsValue("displayErrors") == "True")
DisplayMessage("Error while starting the listener: " + ex.Message,true);
return;
}
connection.Received += data =>
{
//if (tracingEnabled == false)
//{
// // This can happen if user has disabled tracing without stopping the trace
// StopTracing();
//}
if (tracingStarted)
{
XElement traceXml = XElement.Parse(data.ToString());
System.Xml.Linq.XNode firstNode = traceXml.FirstNode;
if (firstNode.ToString().Contains("MessageLogTraceRecord"))
{
AddMessageItem(traceXml);
}
else
{
AddTraceItem(traceXml);
}
}
};
connection.Closed += connection_closed;
connection.StateChanged += connection_StateChanged;
}
else
{
connection.Start();
}
Action.Content = "Stop";
tracingStarted = true;
}
else
{
// tracing is not enabled. Prompt the user to configure tracing
DisplayMessage("Please select a WCF application to trace and then click Start",true);
}
}
else
{
StopTracing();
}
}
private void RunBasicAuth(string serverUrl)
{
string url = serverUrl + "basicauth";
var connection = new Connection(url + "/echo");
connection.TraceWriter = _traceWriter;
connection.Received += (data) => connection.TraceWriter.WriteLine(data);
connection.Credentials = new NetworkCredential("user", "password");
connection.Start().Wait();
connection.Send("sending to AuthenticatedEchoConnection").Wait();
var hubConnection = new HubConnection(url);
hubConnection.TraceWriter = _traceWriter;
hubConnection.Credentials = new NetworkCredential("user", "password");
var hubProxy = hubConnection.CreateHubProxy("AuthHub");
hubProxy.On<string, string>("invoked", (connectionId, date) => hubConnection.TraceWriter.WriteLine("connectionId={0}, date={1}", connectionId, date));
hubConnection.Start().Wait();
hubConnection.TraceWriter.WriteLine("transport.Name={0}", hubConnection.Transport.Name);
hubProxy.Invoke("InvokedFromClient").Wait();
}
public static IDisposable ClientGroupsSyncWithServerGroupsOnReconnectLongPolling()
{
var host = new MemoryHost();
host.Configure(app =>
{
var config = new ConnectionConfiguration()
{
Resolver = new DefaultDependencyResolver()
};
app.MapConnection<MyRejoinGroupConnection>("/groups", config);
var configuration = config.Resolver.Resolve<IConfigurationManager>();
configuration.KeepAlive = null;
configuration.ConnectionTimeout = TimeSpan.FromSeconds(1);
});
var connection = new Client.Connection("http://foo/groups");
var inGroupOnReconnect = new List<bool>();
var wh = new ManualResetEventSlim();
connection.Received += message =>
{
Console.WriteLine(message);
wh.Set();
};
connection.Reconnected += () =>
{
connection.Send(new { type = 3, group = "test", message = "Reconnected" }).Wait();
};
connection.Start(new Client.Transports.LongPollingTransport(host)).Wait();
// Join the group
connection.Send(new { type = 1, group = "test" }).Wait();
Thread.Sleep(TimeSpan.FromSeconds(10));
if (!wh.Wait(TimeSpan.FromSeconds(10)))
{
Debugger.Break();
}
Console.WriteLine(inGroupOnReconnect.Count > 0);
Console.WriteLine(String.Join(", ", inGroupOnReconnect.Select(b => b.ToString())));
connection.Stop();
return host;
}
private static void BroadcastFive(MemoryHost host)
{
var connection = new Client.Connection("http://samples/Raw-connection");
connection.Error += e =>
{
Console.Error.WriteLine("========ERROR==========");
Console.Error.WriteLine(e.GetBaseException().ToString());
Console.Error.WriteLine("=======================");
};
connection.Start(new Client.Transports.ServerSentEventsTransport(host)).Wait();
try
{
for (int i = 0; i < 5; i++)
{
var payload = new
{
type = MessageType.Broadcast,
value = "message " + i.ToString()
};
connection.Send(payload).Wait();
}
}
catch (Exception ex)
{
Console.Error.WriteLine("========ERROR==========");
Console.Error.WriteLine(ex.GetBaseException().ToString());
Console.Error.WriteLine("=======================");
}
finally
{
connection.Stop();
}
}
private void RunAuth(string serverUrl)
{
string url = serverUrl + "cookieauth";
var cookieContainer = new CookieContainer();
var request = (HttpWebRequest)HttpWebRequest.Create(url + "/Account/Login");
request.CookieContainer = cookieContainer;
request.ContentType = "application/x-www-form-urlencoded";
request.Method = "POST";
var content = string.Format("UserName={0}&Password={1}", "user", "password");
byte[] bytedata = Encoding.UTF8.GetBytes(content);
request.ContentLength = bytedata.Length;
Stream requestStream = request.GetRequestStream();
requestStream.Write(bytedata, 0, bytedata.Length);
requestStream.Close();
var response = request.GetResponse();
var connection = new Connection(url + "/echo");
connection.TraceWriter = _traceWriter;
connection.Received += (data) => connection.TraceWriter.WriteLine(data);
connection.CookieContainer = cookieContainer;
connection.Start().Wait();
connection.Send("sending to AuthenticatedEchoConnection").Wait();
var hubConnection = new HubConnection(url);
hubConnection.TraceWriter = _traceWriter;
hubConnection.CookieContainer = cookieContainer;
var hubProxy = hubConnection.CreateHubProxy("AuthHub");
hubProxy.On<string, string>("invoked", (connectionId, date) => hubConnection.TraceWriter.WriteLine("connectionId={0}, date={1}", connectionId, date));
hubConnection.Start().Wait();
hubConnection.TraceWriter.WriteLine("transport.Name={0}", hubConnection.Transport.Name);
hubProxy.Invoke("InvokedFromClient").Wait();
}