public RemoteDeploymentManager(string serviceUrl)
{
serviceUrl = UrlUtility.EnsureTrailingSlash(serviceUrl);
_client = HttpClientHelper.Create(serviceUrl);
// Raise the event when data comes in
_connection = new Connection(serviceUrl + "status");
_connection.Received += data => {
if (StatusChanged != null) {
var result = JsonConvert.DeserializeObject<DeployResult>(data);
StatusChanged(result);
}
};
_connection.Error += exception => {
// If we get a 404 back stop listening for changes
WebException webException = exception as WebException;
if (webException != null) {
var webResponse = (HttpWebResponse)webException.Response;
if (webResponse != null &&
webResponse.StatusCode == HttpStatusCode.NotFound) {
_connection.Stop();
}
}
};
_connection.Closed += () => {
Debug.WriteLine("SignalR connection to {0} was closed.", serviceUrl);
};
_connection.Start().Wait();
}
private static Task ConnectBatch(string url, int batchSize, ConcurrentBag<Connection> connections)
{
var options = new ParallelOptions
{
MaxDegreeOfParallelism = batchSize
};
var tcs = new TaskCompletionSource<object>();
long remaining = batchSize;
Parallel.For(0, batchSize, options, i =>
{
var connection = new Connection(url);
connection.Start().ContinueWith(task =>
{
remaining = Interlocked.Decrement(ref remaining);
if (task.IsFaulted)
{
Console.WriteLine("Failed to start client. {0}", task.Exception.GetBaseException());
}
else
{
connections.Add(connection);
var clientId = connection.ConnectionId;
//connection.Received += data =>
//{
// Console.WriteLine("Client {0} RECEIVED: {1}", clientId, data);
//};
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));
};
}
if (Interlocked.Read(ref remaining) == 0)
{
// When all connections are connected, mark the task as complete
tcs.TrySetResult(null);
}
});
});
return tcs.Task;
}
public void FailedNegotiateShouldNotBeActive()
{
var connection = new Connection("http://test");
var transport = new Mock<IClientTransport>();
transport.Setup(m => m.Negotiate(connection))
.Returns(TaskAsyncHelper.FromError<NegotiationResponse>(new InvalidOperationException("Something failed.")));
var aggEx = Assert.Throws<AggregateException>(() => connection.Start(transport.Object).Wait());
var ex = aggEx.Unwrap();
Assert.IsType(typeof(InvalidOperationException), ex);
Assert.Equal("Something failed.", ex.Message);
Assert.Equal(ConnectionState.Disconnected, connection.State);
}
public void FailsIfProtocolVersionIsNull()
{
var connection = new Connection("http://test");
var transport = new Mock<IClientTransport>();
transport.Setup(m => m.Negotiate(connection)).Returns(TaskAsyncHelper.FromResult(new NegotiationResponse
{
ProtocolVersion = null
}));
var aggEx = Assert.Throws<AggregateException>(() => connection.Start(transport.Object).Wait());
var ex = aggEx.Unwrap();
Assert.IsType(typeof(InvalidOperationException), ex);
Assert.Equal("Incompatible protocol version.", ex.Message);
}
protected override void OnNavigatedTo(System.Windows.Navigation.NavigationEventArgs e)
{
base.OnNavigatedTo(e);
var connection = new Connection("http://mxm-signalr.azurewebsites.net/raw-connection");
connection.Received += data => Report(data);
connection.Reconnected += () => Report("[{0}]: Connection restablished", DateTime.Now);
connection.StateChanged += change => Report(change.OldState + " => " + change.NewState);
connection.Error += ex =>
{
Report("========ERROR==========" + ex.Message + "=======================");
};
connection.Start();
}
// Constructor
public MainPage()
{
InitializeComponent();
// Set the data context of the listbox control to the sample data
DataContext = App.ViewModel;
this.Loaded += new RoutedEventHandler(MainPage_Loaded);
var connection = new Connection("http://signalr-sample.azurewebsites.net/raw-connection/");
connection.Received += data =>
{
Dispatcher.BeginInvoke(() =>
{
App.ViewModel.Items.Add(new ItemViewModel { LineOne = data });
});
};
connection.Error += ex =>
{
Dispatcher.BeginInvoke(() =>
{
var aggEx = (AggregateException)ex;
App.ViewModel.Items.Add(new ItemViewModel { LineOne = aggEx.InnerExceptions[0].Message });
});
};
connection.Reconnected += () =>
{
Dispatcher.BeginInvoke(() =>
{
App.ViewModel.Items.Add(new ItemViewModel { LineOne = "Connection restored" });
});
};
var scheduler = TaskScheduler.FromCurrentSynchronizationContext();
connection.Start().ContinueWith(task =>
{
var ex = task.Exception.InnerExceptions[0];
App.ViewModel.Items.Add(new ItemViewModel { LineOne = ex.Message });
},
CancellationToken.None,
TaskContinuationOptions.OnlyOnFaulted,
scheduler);
}
public void FailedStartShouldNotBeActive()
{
var connection = new Connection("http://test");
var transport = new Mock<IClientTransport>();
transport.Setup(m => m.Negotiate(connection))
.Returns(TaskAsyncHelper.FromResult(new NegotiationResponse
{
ProtocolVersion = "1.1",
ConnectionId = "Something"
}));
transport.Setup(m => m.Start(connection, null, It.IsAny<CancellationToken>()))
.Returns(TaskAsyncHelper.FromError(new InvalidOperationException("Something failed.")));
var aggEx = Assert.Throws<AggregateException>(() => connection.Start(transport.Object).Wait());
var ex = aggEx.Unwrap();
Assert.IsType(typeof(InvalidOperationException), ex);
Assert.Equal("Something failed.", ex.Message);
Assert.Equal(ConnectionState.Disconnected, connection.State);
}
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 async Task RunRawConnection(string serverUrl)
{
string url = serverUrl + "raw-connection";
var connection = new Connection(url);
connection.TraceWriter = _traceWriter;
await connection.Start();
connection.TraceWriter.WriteLine("transport.Name={0}", connection.Transport.Name);
await connection.Send(new { type = 1, value = "first message" });
await connection.Send(new { type = 1, value = "second message" });
}
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");
}
static void Main(string[] args)
{
Console.WriteLine("Crank v{0}", typeof(Program).Assembly.GetName().Version);
if (args.Length < 2)
{
Console.WriteLine("Usage: crank [url] [numclients]");
return;
}
ServicePointManager.DefaultConnectionLimit = Int32.MaxValue;
string url = args[0];
int clients = Int32.Parse(args[1]);
TaskScheduler.UnobservedTaskException += OnUnobservedTaskException;
var connections = new ConcurrentBag<Connection>();
var sw = Stopwatch.StartNew();
Task.Factory.StartNew(() =>
{
Parallel.For(0, clients, i =>
{
try
{
var connection = new Connection(url);
connection.Received += data =>
{
Console.WriteLine(data);
};
connection.Error += e =>
{
Console.WriteLine("ERROR: Client {0}, {1}", i, e.GetBaseException());
};
connection.Closed += () =>
{
Console.WriteLine("CLOSED: {0}", i);
};
connection.Start().Wait();
connections.Add(connection);
}
catch (Exception e)
{
Console.WriteLine("Failed to start client {0}. {1}", i, e);
}
});
Console.WriteLine("Started {0} connection(s).", connections.Count);
});
Console.WriteLine("Press any key to stop running...");
Console.Read();
sw.Stop();
Console.WriteLine("Total Running time: {0}s", sw.Elapsed);
Console.WriteLine("End point: {0}", url);
Console.WriteLine("Total connections: {0}", clients);
Console.WriteLine("Active connections: {0}", connections.Count(c => c.IsActive));
Console.WriteLine("Stopped connections: {0}", connections.Count(c => !c.IsActive));
}
private void button1_Click(object sender, EventArgs e)
{
if (!int.TryParse(textPort.Text, out port))
{
MessageBox.Show("Please enter a number in the port section.");
DialogResult = DialogResult.None;
return;
}
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
socket.Connect(Hostname, port);
}
catch
{
MessageBox.Show("Unable to connect to chosen server on specified port.");
DialogResult = DialogResult.None;
return;
}
try
{
Connection con = new Connection(socket, ParentShard);
player.Name = textUsername.Text;
SHA256 hasher = SHA256.Create();
player.PasswordHash = hasher.ComputeHash(Encoding.Unicode.GetBytes(textPassword.Text));
player.Connection = con;
con.Player = player;
con.Start();
HelloResponse res = (HelloResponse)con.SendMessage(new HelloMessage());
if (!res.Success)
{
MessageBox.Show("Client version incompatible with selected server.");
DialogResult = DialogResult.None;
return;
}
byte[] publicKeyData = res.PublicKeyData;
byte[] nonce = res.Nonce;
Message response = con.SendMessage(new LoginPlayerMessage(player.Name, player.PasswordHash, publicKeyData, nonce));
LoginPlayerResponseMessage realResponse = response as LoginPlayerResponseMessage;
if (realResponse != null)
{
if (!realResponse.Success)
{
if (MessageBox.Show("Username does not exist or password wrong, should I attempt to create a new player?", "Login failure.", MessageBoxButtons.YesNo) == DialogResult.Yes)
{
// TODO - confirm password.
response = con.SendMessage(new CreatePlayerMessage(player.Name, player.PasswordHash, publicKeyData, nonce));
CreatePlayerResponseMessage realResponse2 = response as CreatePlayerResponseMessage;
if (realResponse2 != null)
{
if (realResponse2.Success)
{
MessageBox.Show("Player successfully created.");
return;
}
else
{
MessageBox.Show("Name already exists, choose another.");
DialogResult = DialogResult.None;
return;
}
}
else
throw new NotSupportedException("Unexpected response type from server.");
}
else
{
DialogResult = DialogResult.None;
return;
}
}
}
else
throw new NotSupportedException("Unexpected response received from server.");
}
catch
{
MessageBox.Show("Unexpected error occured while logging in.");
DialogResult = DialogResult.None;
return;
}
}
private async Task 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");
await connection.Start();
await connection.Send("sending to AuthenticatedEchoConnection");
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));
await hubConnection.Start();
hubConnection.TraceWriter.WriteLine("transport.Name={0}", hubConnection.Transport.Name);
await hubProxy.Invoke("InvokedFromClient");
}